diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index bfa9091c7..72c990474 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -1,2 +1,2 @@ # CODEOWNERS: https://help.github.com/articles/about-codeowners/ -* @jackzampolin @jtieri @boojamya @mark-rushakoff +* @jtieri @boojamya @agouin diff --git a/.github/workflows/interchaintest.yml b/.github/workflows/interchaintest.yml index 9d9d1165d..21b94448b 100644 --- a/.github/workflows/interchaintest.yml +++ b/.github/workflows/interchaintest.yml @@ -147,15 +147,20 @@ jobs: outputs: matrix: ${{ steps.set-matrix.outputs.matrix }} steps: - - name: Checkout code - uses: actions/checkout@v4 - - - name: Generate matrix - id: set-matrix - run: | - # Run the command and convert its output to a JSON array - TESTS=$(cd interchaintest && go test -list ^TestScenario ./... | grep -v "^ok " | jq -R -s -c 'split("\n")[:-1]') - echo "matrix=${TESTS}" >> $GITHUB_OUTPUT + - name: Set up Go 1.21 + uses: actions/setup-go@v4 + with: + go-version: '1.21' + + - name: Checkout code + uses: actions/checkout@v4 + + - name: Generate matrix + id: set-matrix + run: | + # Run the command and convert its output to a JSON array + TESTS=$(cd interchaintest && go test -list ^TestScenario ./... | grep -v "^ok " | grep -v "proto: duplicate proto type registered" | jq -R -s -c 'split("\n")[:-1]') + echo "matrix=${TESTS}" >> $GITHUB_OUTPUT # Note : This job will not start until prepare-scenario-matrix completes sucessfully scenarios: diff --git a/.github/workflows/strangelove-project-management.yaml b/.github/workflows/strangelove-project-management.yaml new file mode 100644 index 000000000..4cc9bac04 --- /dev/null +++ b/.github/workflows/strangelove-project-management.yaml @@ -0,0 +1,20 @@ +name: Strangelove Project Management + +on: + issues: + types: + - opened + - transferred + - reopened + +jobs: + add-to-project: + name: Add issue to project + runs-on: ubuntu-latest + steps: + - uses: actions/add-to-project@v0.5.0 + with: + # You can target a project in a different organization + # to the issue + project-url: https://github.com/orgs/strangelove-ventures/projects/4 + github-token: ${{ secrets.strangelove_motherboard_access_token }} \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index d5a46901d..fe923eecd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -25,6 +25,11 @@ * [\#1231](https://github.com/cosmos/relayer/pull/1231) Reduce get bech32 prefix when get signer. * [\#1302](https://github.com/cosmos/relayer/pull/1302) Avoid packet get relayed when estimated gas is higher than max gas. * [\#1303](https://github.com/cosmos/relayer/pull/1303) Add missing max gas amount on txf to avoid estimate less gas when simualte runTx. +* [\#1324](https://github.com/cosmos/relayer/pull/1324) Add log-level in global config. +* [\#1325](https://github.com/cosmos/relayer/pull/1325) Ignore only file not exist error when loadConfigFile. +* [\#1326](https://github.com/cosmos/relayer/pull/1326) Avoid sending channel close confirm message after channel get closed successfully. +* [\#1364](https://github.com/cosmos/relayer/pull/1364) Include feegrant message when calculate gas. +* [\#1390](https://github.com/cosmos/relayer/pull/1390) Avoid no concrete type registered for type URL error of EthAccount. ## v0.9.3 diff --git a/Makefile b/Makefile index 20e9bbb2b..d27c4c7ec 100644 --- a/Makefile +++ b/Makefile @@ -123,7 +123,7 @@ build-gaia: .PHONY: two-chains test test-integration interchaintest install build lint coverage clean PACKAGE_NAME := github.com/cosmos/relayer -GOLANG_CROSS_VERSION ?= v1.19.4 +GOLANG_CROSS_VERSION ?= v1.21.5 SYSROOT_DIR ?= sysroots SYSROOT_ARCHIVE ?= sysroots.tar.bz2 diff --git a/README.md b/README.md index 9fc564aee..d08f5a8d1 100644 --- a/README.md +++ b/README.md @@ -200,8 +200,8 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n ## Security Notice -If you would like to report a security critical bug related to the relayer repo, -please reach out @jackzampolin or @Ethereal0ne on telegram. +If you would like to report a security bug related to the relayer repo, +please follow the instructions in [SECURITY.md](SECURITY.md). ## Code of Conduct diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 000000000..368ae92cc --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,53 @@ +# Coordinated Vulnerability Disclosure Policy + +The Cosmos ecosystem believes that strong security is a blend of highly +technical security researchers who care about security and the forward +progression of the ecosystem and the attentiveness and openness of Cosmos core +contributors to help continually secure our operations. + +> **IMPORTANT**: *DO NOT* open public issues on this repository for security +> vulnerabilities. + +## Reporting a Vulnerability + +| Reporting methods | Bounty eligible | +|---------------------------------------------------------------|-----------------| +| [HackerOne program][h1] | yes | +| [security@interchain.io](mailto:security@interchain.io) | no | + +Issues identified in this repository may be eligible for a [bug bounty][h1]. For your report to be bounty +eligible it must be reported exclusively through the [HackerOne Bug Bounty][h1]. + +If you do not wish to be eligible for a bounty or do not want to use the HackerOne platform to report an +issue, please send your report via email to [security@interchain.io](mailto:security@interchain.io) with +reproduction steps and details of the issue. + +### Guidelines + +We require that all researchers: + +* Abide by this policy to disclose vulnerabilities, and avoid posting + vulnerability information in public places, including GitHub, Discord, + Telegram, and Twitter. +* Make every effort to avoid privacy violations, degradation of user experience, + disruption to production systems (including but not limited to the Cosmos + Hub), and destruction of data. +* Keep any information about vulnerabilities that you’ve discovered confidential + between yourself and the Cosmos engineering team until the issue has been + resolved and disclosed. +* Avoid posting personally identifiable information, privately or publicly. + +If you follow these guidelines when reporting an issue to us, we commit to: + +* Not pursue or support any legal action related to your research on this + vulnerability +* Work with you to understand, resolve and ultimately disclose the issue in a + timely fashion + +## Coordinated Vulnerability Disclosure Policy and Safe Harbor + +For the most up-to-date version of the policies that govern vulnerability disclosure, please consult the [HackerOne program page](https://hackerone.com/cosmos?type=team&view_policy=true). + +The policy hosted on HackerOne is the official Coordinated Vulnerability Disclosure policy and Safe Harbor for the Interchain Stack, and the teams and infrastructure it supports, and it supersedes previous security policies that have been used in the past by individual teams and projects with targets in scope of the program. + +[h1]: https://hackerone.com/cosmos diff --git a/client/client_wrapper.go b/client/client_wrapper.go new file mode 100644 index 000000000..9825dffae --- /dev/null +++ b/client/client_wrapper.go @@ -0,0 +1,580 @@ +package client + +import ( + "context" + + "github.com/cometbft/cometbft/abci/types" + cometcrypto "github.com/cometbft/cometbft/crypto" + ced25519 "github.com/cometbft/cometbft/crypto/ed25519" + "github.com/cometbft/cometbft/crypto/merkle" + csecp256k1 "github.com/cometbft/cometbft/crypto/secp256k1" + csr25519 "github.com/cometbft/cometbft/crypto/sr25519" + "github.com/cometbft/cometbft/libs/bytes" + "github.com/cometbft/cometbft/p2p" + "github.com/cometbft/cometbft/proto/tendermint/crypto" + rpcclient "github.com/cometbft/cometbft/rpc/client" + coretypes "github.com/cometbft/cometbft/rpc/core/types" + tmtypes "github.com/cometbft/cometbft/types" + sdk "github.com/cosmos/cosmos-sdk/types" + sltypes "github.com/strangelove-ventures/cometbft-client/abci/types" + "github.com/strangelove-ventures/cometbft-client/client" + slcrypto "github.com/strangelove-ventures/cometbft-client/crypto" + "github.com/strangelove-ventures/cometbft-client/crypto/ed25519" + "github.com/strangelove-ventures/cometbft-client/crypto/secp256k1" + "github.com/strangelove-ventures/cometbft-client/crypto/sr25519" + slbytes "github.com/strangelove-ventures/cometbft-client/libs/bytes" + slclient "github.com/strangelove-ventures/cometbft-client/rpc/client" + coretypes2 "github.com/strangelove-ventures/cometbft-client/rpc/core/types" + types2 "github.com/strangelove-ventures/cometbft-client/types" +) + +// RPCClient wraps our slimmed down CometBFT client and converts the returned types to the upstream CometBFT types. +// This is useful so that it can be used in any function calls that expect the upstream types. +type RPCClient struct { + c *client.Client +} + +func NewRPCClient(c *client.Client) RPCClient { + return RPCClient{c: c} +} + +func (r RPCClient) ABCIInfo(ctx context.Context) (*coretypes.ResultABCIInfo, error) { + res, err := r.c.ABCIInfo(ctx) + if err != nil { + return nil, err + } + + return &coretypes.ResultABCIInfo{ + Response: types.ResponseInfo{ + Data: res.Response.Data, + Version: res.Response.Version, + AppVersion: res.Response.AppVersion, + LastBlockHeight: res.Response.LastBlockHeight, + LastBlockAppHash: res.Response.LastBlockAppHash, + }, + }, nil +} + +func (r RPCClient) ABCIQuery( + ctx context.Context, + path string, + data bytes.HexBytes, +) (*coretypes.ResultABCIQuery, error) { + res, err := r.c.ABCIQuery(ctx, path, slbytes.HexBytes(data)) + if err != nil { + return nil, err + } + + return convertResultABCIQuery(res), nil +} + +func (r RPCClient) ABCIQueryWithOptions( + ctx context.Context, + path string, + data bytes.HexBytes, + opts rpcclient.ABCIQueryOptions, +) (*coretypes.ResultABCIQuery, error) { + o := slclient.ABCIQueryOptions{ + Height: opts.Height, + Prove: opts.Prove, + } + + res, err := r.c.ABCIQueryWithOptions(ctx, path, slbytes.HexBytes(data), o) + if err != nil { + return nil, err + } + + return convertResultABCIQuery(res), nil +} + +func (r RPCClient) BroadcastTxCommit(ctx context.Context, tx tmtypes.Tx) (*coretypes.ResultBroadcastTxCommit, error) { + res, err := r.c.BroadcastTxCommit(ctx, types2.Tx(tx)) + if err != nil { + return nil, err + } + + return &coretypes.ResultBroadcastTxCommit{ + CheckTx: types.ResponseCheckTx{ + Code: res.CheckTx.Code, + Data: res.CheckTx.Data, + Log: res.CheckTx.Log, + Info: res.CheckTx.Info, + GasWanted: res.CheckTx.GasWanted, + GasUsed: res.CheckTx.GasUsed, + Events: convertEvents(res.CheckTx.Events), + Codespace: res.CheckTx.Codespace, + }, + TxResult: types.ExecTxResult{ + Code: res.TxResult.Code, + Data: res.TxResult.Data, + Log: res.TxResult.Log, + Info: res.TxResult.Info, + GasWanted: res.TxResult.GasWanted, + GasUsed: res.TxResult.GasUsed, + Events: convertEvents(res.TxResult.Events), + Codespace: res.TxResult.Codespace, + }, + Hash: bytes.HexBytes(res.Hash), + Height: res.Height, + }, nil +} + +func (r RPCClient) BroadcastTxAsync(ctx context.Context, tx tmtypes.Tx) (*coretypes.ResultBroadcastTx, error) { + res, err := r.c.BroadcastTxAsync(ctx, types2.Tx(tx)) + if err != nil { + return nil, err + } + + return &coretypes.ResultBroadcastTx{ + Code: res.Code, + Data: bytes.HexBytes(res.Data), + Log: res.Log, + Codespace: res.Codespace, + Hash: bytes.HexBytes(res.Hash), + }, nil +} + +func (r RPCClient) BroadcastTxSync(ctx context.Context, tx tmtypes.Tx) (*coretypes.ResultBroadcastTx, error) { + res, err := r.c.BroadcastTxSync(ctx, types2.Tx(tx)) + if err != nil { + return nil, err + } + + return &coretypes.ResultBroadcastTx{ + Code: res.Code, + Data: bytes.HexBytes(res.Data), + Log: res.Log, + Codespace: res.Codespace, + Hash: bytes.HexBytes(res.Hash), + }, nil +} + +func (r RPCClient) Validators( + ctx context.Context, + height *int64, + page, perPage *int, +) (*coretypes.ResultValidators, error) { + res, err := r.c.Validators(ctx, height, page, perPage) + if err != nil { + return nil, err + } + + vals := make([]*tmtypes.Validator, len(res.Validators)) + for i, val := range res.Validators { + vals[i] = &tmtypes.Validator{ + Address: tmtypes.Address(val.Address), + PubKey: convertPubKey(val.PubKey), + VotingPower: val.VotingPower, + ProposerPriority: val.ProposerPriority, + } + } + + return &coretypes.ResultValidators{ + BlockHeight: res.BlockHeight, + Validators: vals, + Count: res.Count, + Total: res.Total, + }, nil +} + +func (r RPCClient) Status(ctx context.Context) (*coretypes.ResultStatus, error) { + res, err := r.c.Status(ctx) + if err != nil { + return nil, err + } + + return &coretypes.ResultStatus{ + NodeInfo: p2p.DefaultNodeInfo{ + ProtocolVersion: p2p.ProtocolVersion{ + P2P: res.NodeInfo.ProtocolVersion.P2P, + Block: res.NodeInfo.ProtocolVersion.Block, + App: res.NodeInfo.ProtocolVersion.App, + }, + DefaultNodeID: p2p.ID(res.NodeInfo.DefaultNodeID), + ListenAddr: res.NodeInfo.ListenAddr, + Network: res.NodeInfo.Network, + Version: res.NodeInfo.Version, + Channels: bytes.HexBytes(res.NodeInfo.Channels), + Moniker: res.NodeInfo.Moniker, + Other: p2p.DefaultNodeInfoOther{ + TxIndex: res.NodeInfo.Other.TxIndex, + RPCAddress: res.NodeInfo.Other.RPCAddress, + }, + }, + SyncInfo: coretypes.SyncInfo{ + LatestBlockHash: bytes.HexBytes(res.SyncInfo.LatestBlockHash), + LatestAppHash: bytes.HexBytes(res.SyncInfo.LatestAppHash), + LatestBlockHeight: res.SyncInfo.LatestBlockHeight, + LatestBlockTime: res.SyncInfo.LatestBlockTime, + EarliestBlockHash: bytes.HexBytes(res.SyncInfo.EarliestBlockHash), + EarliestAppHash: bytes.HexBytes(res.SyncInfo.EarliestAppHash), + EarliestBlockHeight: res.SyncInfo.EarliestBlockHeight, + EarliestBlockTime: res.SyncInfo.EarliestBlockTime, + CatchingUp: res.SyncInfo.CatchingUp, + }, + ValidatorInfo: coretypes.ValidatorInfo{ + Address: bytes.HexBytes(res.ValidatorInfo.Address), + PubKey: convertPubKey(res.ValidatorInfo.PubKey), + VotingPower: res.ValidatorInfo.VotingPower, + }, + }, nil +} + +func (r RPCClient) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) { + res, err := r.c.Block(ctx, height) + if err != nil { + return nil, err + } + + return &coretypes.ResultBlock{ + BlockID: convertBlockID(res.BlockID), + Block: convertBlock(res.Block), + }, nil +} + +func (r RPCClient) BlockByHash(ctx context.Context, hash []byte) (*coretypes.ResultBlock, error) { + res, err := r.c.BlockByHash(ctx, hash) + if err != nil { + return nil, err + } + + return &coretypes.ResultBlock{ + BlockID: convertBlockID(res.BlockID), + Block: convertBlock(res.Block), + }, nil +} + +func (r RPCClient) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) { + res, err := r.c.BlockResults(ctx, height) + if err != nil { + return nil, err + } + + txs := make([]*types.ExecTxResult, len(res.TxResponses)) + for i, tx := range res.TxResponses { + txs[i] = &types.ExecTxResult{ + Code: tx.Code, + Data: tx.Data, + Log: tx.Log, + Info: tx.Info, + GasWanted: tx.GasWanted, + GasUsed: tx.GasUsed, + Events: converStringEvents(tx.Events), + Codespace: tx.Codespace, + } + } + + return &coretypes.ResultBlockResults{ + Height: res.Height, + TxsResults: txs, + FinalizeBlockEvents: converStringEvents(res.Events), + ValidatorUpdates: nil, + ConsensusParamUpdates: nil, + AppHash: res.AppHash, + }, nil +} + +func (r RPCClient) BlockchainInfo( + ctx context.Context, + minHeight, maxHeight int64, +) (*coretypes.ResultBlockchainInfo, error) { + res, err := r.c.BlockchainInfo(ctx, minHeight, maxHeight) + if err != nil { + return nil, err + } + + meta := make([]*tmtypes.BlockMeta, len(res.BlockMetas)) + for i, m := range res.BlockMetas { + meta[i] = &tmtypes.BlockMeta{ + BlockID: tmtypes.BlockID{ + Hash: bytes.HexBytes(m.BlockID.Hash), + PartSetHeader: tmtypes.PartSetHeader{ + Total: m.BlockID.PartSetHeader.Total, + Hash: bytes.HexBytes(m.BlockID.PartSetHeader.Hash), + }, + }, + BlockSize: m.BlockSize, + Header: convertHeader(m.Header), + NumTxs: m.NumTxs, + } + } + + return &coretypes.ResultBlockchainInfo{ + LastHeight: res.LastHeight, + BlockMetas: meta, + }, nil +} + +func (r RPCClient) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) { + res, err := r.c.Commit(ctx, height) + if err != nil { + return nil, err + } + + signatures := make([]tmtypes.CommitSig, len(res.Commit.Signatures)) + for i, sig := range res.Commit.Signatures { + signatures[i] = tmtypes.CommitSig{ + BlockIDFlag: tmtypes.BlockIDFlag(sig.BlockIDFlag), + ValidatorAddress: tmtypes.Address(sig.ValidatorAddress), + Timestamp: sig.Timestamp, + Signature: sig.Signature, + } + } + + header := convertHeader(*res.SignedHeader.Header) + return &coretypes.ResultCommit{ + SignedHeader: tmtypes.SignedHeader{ + Header: &header, + Commit: &tmtypes.Commit{ + Height: res.Commit.Height, + Round: res.Commit.Round, + BlockID: convertBlockID(res.Commit.BlockID), + Signatures: signatures, + }, + }, + CanonicalCommit: res.CanonicalCommit, + }, nil +} + +func (r RPCClient) Tx(ctx context.Context, hash []byte, prove bool) (*coretypes.ResultTx, error) { + res, err := r.c.Tx(ctx, hash, prove) + if err != nil { + return nil, err + } + + return convertResultTx(res), nil +} + +func (r RPCClient) TxSearch( + ctx context.Context, + query string, + prove bool, + page, perPage *int, + orderBy string, +) (*coretypes.ResultTxSearch, error) { + res, err := r.c.TxSearch(ctx, query, prove, page, perPage, orderBy) + if err != nil { + return nil, err + } + + txs := make([]*coretypes.ResultTx, len(res)) + for i, tx := range res { + txs[i] = convertResultTx(tx) + } + + return &coretypes.ResultTxSearch{ + Txs: txs, + TotalCount: len(txs), + }, nil +} + +func (r RPCClient) BlockSearch( + ctx context.Context, + query string, + page, perPage *int, + orderBy string, +) (*coretypes.ResultBlockSearch, error) { + res, err := r.c.BlockSearch(ctx, query, page, perPage, orderBy) + if err != nil { + return nil, err + } + + blocks := make([]*coretypes.ResultBlock, len(res.Blocks)) + for i, block := range res.Blocks { + blocks[i] = &coretypes.ResultBlock{ + BlockID: convertBlockID(block.BlockID), + Block: convertBlock(block.Block), + } + } + + return &coretypes.ResultBlockSearch{ + Blocks: blocks, + TotalCount: res.TotalCount, + }, nil +} + +func convertProofOps(proofOps *sltypes.ProofOps) *crypto.ProofOps { + ops := make([]crypto.ProofOp, len(proofOps.Ops)) + for i, op := range proofOps.Ops { + ops[i] = crypto.ProofOp{ + Type: op.Type, + Key: op.Key, + Data: op.Data, + } + } + + return &crypto.ProofOps{Ops: ops} +} + +func convertEvents(events []sltypes.Event) []types.Event { + evts := make([]types.Event, len(events)) + + for i, evt := range events { + attributes := make([]types.EventAttribute, len(evt.Attributes)) + + for j, attr := range evt.Attributes { + attributes[j] = types.EventAttribute{ + Key: attr.Key, + Value: attr.Value, + Index: attr.Index, + } + } + + evts[i] = types.Event{ + Type: evt.Type, + Attributes: attributes, + } + } + + return evts +} + +func converStringEvents(events sdk.StringEvents) []types.Event { + evts := make([]types.Event, len(events)) + + for i, evt := range events { + attributes := make([]types.EventAttribute, len(evt.Attributes)) + + for j, attr := range evt.Attributes { + attributes[j] = types.EventAttribute{ + Key: attr.Key, + Value: attr.Value, + } + } + + evts[i] = types.Event{ + Type: evt.Type, + Attributes: attributes, + } + } + + return evts +} + +func convertHeader(header types2.Header) tmtypes.Header { + return tmtypes.Header{ + ChainID: header.ChainID, + Height: header.Height, + Time: header.Time, + LastBlockID: tmtypes.BlockID{ + Hash: bytes.HexBytes(header.LastBlockID.Hash), + PartSetHeader: tmtypes.PartSetHeader{ + Total: header.LastBlockID.PartSetHeader.Total, + Hash: bytes.HexBytes(header.LastBlockID.PartSetHeader.Hash), + }, + }, + LastCommitHash: bytes.HexBytes(header.LastCommitHash), + DataHash: bytes.HexBytes(header.DataHash), + ValidatorsHash: bytes.HexBytes(header.ValidatorsHash), + NextValidatorsHash: bytes.HexBytes(header.NextValidatorsHash), + ConsensusHash: bytes.HexBytes(header.ConsensusHash), + AppHash: bytes.HexBytes(header.AppHash), + LastResultsHash: bytes.HexBytes(header.LastResultsHash), + EvidenceHash: bytes.HexBytes(header.EvidenceHash), + ProposerAddress: tmtypes.Address(header.ProposerAddress), + } +} + +func convertBlockID(id types2.BlockID) tmtypes.BlockID { + return tmtypes.BlockID{ + Hash: bytes.HexBytes(id.Hash), + PartSetHeader: tmtypes.PartSetHeader{ + Total: id.PartSetHeader.Total, + Hash: bytes.HexBytes(id.PartSetHeader.Hash), + }, + } +} + +func convertBlock(block *types2.Block) *tmtypes.Block { + signatures := make([]tmtypes.CommitSig, len(block.LastCommit.Signatures)) + for i, sig := range block.LastCommit.Signatures { + signatures[i] = tmtypes.CommitSig{ + BlockIDFlag: tmtypes.BlockIDFlag(sig.BlockIDFlag), + ValidatorAddress: tmtypes.Address(sig.ValidatorAddress), + Timestamp: sig.Timestamp, + Signature: sig.Signature, + } + } + + txs := make([]tmtypes.Tx, len(block.Data.Txs)) + for i, tx := range block.Data.Txs { + txs[i] = tmtypes.Tx(tx) + } + + return &tmtypes.Block{ + Header: convertHeader(block.Header), + Data: tmtypes.Data{ + Txs: txs, + }, + Evidence: tmtypes.EvidenceData{}, + LastCommit: &tmtypes.Commit{ + Height: block.LastCommit.Height, + Round: block.LastCommit.Round, + BlockID: convertBlockID(block.LastCommit.BlockID), + Signatures: signatures, + }, + } +} + +func convertResultABCIQuery(res *coretypes2.ResultABCIQuery) *coretypes.ResultABCIQuery { + var ops *crypto.ProofOps + if res.Response.ProofOps != nil { + ops = convertProofOps(res.Response.ProofOps) + } + + return &coretypes.ResultABCIQuery{ + Response: types.ResponseQuery{ + Code: res.Response.Code, + Log: res.Response.Log, + Info: res.Response.Info, + Index: res.Response.Index, + Key: res.Response.Key, + Value: res.Response.Value, + ProofOps: ops, + Height: res.Response.Height, + Codespace: res.Response.Codespace, + }, + } +} + +func convertResultTx(res *client.TxResponse) *coretypes.ResultTx { + return &coretypes.ResultTx{ + Hash: bytes.HexBytes(res.Hash), + Height: res.Height, + Index: res.Index, + TxResult: types.ExecTxResult{ + Code: res.ExecTx.Code, + Data: res.ExecTx.Data, + Log: res.ExecTx.Log, + Info: res.ExecTx.Info, + GasWanted: res.ExecTx.GasWanted, + GasUsed: res.ExecTx.GasUsed, + Events: converStringEvents(res.ExecTx.Events), + Codespace: res.ExecTx.Codespace, + }, + Tx: tmtypes.Tx(res.Tx), + Proof: tmtypes.TxProof{ + RootHash: bytes.HexBytes(res.Proof.RootHash), + Data: tmtypes.Tx(res.Proof.Data), + Proof: merkle.Proof{ + Total: res.Proof.Proof.Total, + Index: res.Proof.Proof.Index, + LeafHash: res.Proof.Proof.LeafHash, + Aunts: res.Proof.Proof.Aunts, + }, + }, + } +} + +func convertPubKey(pk slcrypto.PubKey) cometcrypto.PubKey { + switch key := pk.(type) { + case ed25519.PubKey: + return ced25519.PubKey(key) + case secp256k1.PubKey: + return csecp256k1.PubKey(key) + case sr25519.PubKey: + return csr25519.PubKey(key) + default: + return nil + } +} diff --git a/cmd/appstate.go b/cmd/appstate.go index 738e9af40..44aff4736 100644 --- a/cmd/appstate.go +++ b/cmd/appstate.go @@ -6,6 +6,7 @@ import ( "errors" "fmt" "io" + "io/fs" "os" "path" @@ -30,6 +31,22 @@ type appState struct { config *Config } +func (a *appState) initLogger(configLogLevel string) error { + logLevel := a.viper.GetString("log-level") + if a.viper.GetBool("debug") { + logLevel = "debug" + } else if logLevel == "" { + logLevel = configLogLevel + } + log, err := newRootLogger(a.viper.GetString("log-format"), logLevel) + if err != nil { + return err + } + + a.log = log + return nil +} + func (a *appState) configPath() string { return path.Join(a.homePath, "config", "config.yaml") } @@ -40,7 +57,10 @@ func (a *appState) loadConfigFile(ctx context.Context) error { if _, err := os.Stat(cfgPath); err != nil { // don't return error if file doesn't exist - return nil + if errors.Is(err, fs.ErrNotExist) { + err = nil + } + return err } // read the config file bytes @@ -56,6 +76,10 @@ func (a *appState) loadConfigFile(ctx context.Context) error { return fmt.Errorf("error unmarshalling config: %w", err) } + if a.log == nil { + a.initLogger(cfgWrapper.Global.LogLevel) + } + // retrieve the runtime configuration from the disk configuration. newCfg, err := cfgWrapper.RuntimeConfig(ctx, a) if err != nil { diff --git a/cmd/config.go b/cmd/config.go index 80ae95e4c..2b8bde934 100644 --- a/cmd/config.go +++ b/cmd/config.go @@ -488,19 +488,24 @@ func DefaultConfig(memo string) *Config { // GlobalConfig describes any global relayer settings type GlobalConfig struct { - APIListenPort string `yaml:"api-listen-addr" json:"api-listen-addr"` - Timeout string `yaml:"timeout" json:"timeout"` - Memo string `yaml:"memo" json:"memo"` - LightCacheSize int `yaml:"light-cache-size" json:"light-cache-size"` + APIListenPort string `yaml:"api-listen-addr" json:"api-listen-addr"` + Timeout string `yaml:"timeout" json:"timeout"` + Memo string `yaml:"memo" json:"memo"` + LightCacheSize int `yaml:"light-cache-size" json:"light-cache-size"` + LogLevel string `yaml:"log-level" json:"log-level"` + ICS20MemoLimit int `yaml:"ics20-memo-limit" json:"ics20-memo-limit"` + MaxReceiverSize int `yaml:"max-receiver-size" json:"max-receiver-size"` } // newDefaultGlobalConfig returns a global config with defaults set func newDefaultGlobalConfig(memo string) GlobalConfig { return GlobalConfig{ - APIListenPort: ":5183", - Timeout: "10s", - LightCacheSize: 20, - Memo: memo, + APIListenPort: ":5183", + Timeout: "10s", + LightCacheSize: 20, + Memo: memo, + LogLevel: "info", + MaxReceiverSize: 150, } } diff --git a/cmd/feegrant.go b/cmd/feegrant.go index edb66d800..2d7055b4e 100644 --- a/cmd/feegrant.go +++ b/cmd/feegrant.go @@ -4,8 +4,11 @@ import ( "errors" "fmt" + sdkflags "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/relayer/v2/relayer/chains/cosmos" "github.com/spf13/cobra" + "go.uber.org/zap" ) // feegrantConfigureCmd returns the fee grant configuration commands for this module @@ -52,18 +55,27 @@ func feegrantConfigureBasicCmd(a *appState) *cobra.Command { if len(args) > 1 { granterKeyOrAddr = args[1] } else if prov.PCfg.FeeGrants != nil { - granterKeyOrAddr = prov.PCfg.FeeGrants.GranterKey + granterKeyOrAddr = prov.PCfg.FeeGrants.GranterKeyOrAddr } else { granterKeyOrAddr = prov.PCfg.Key } + externalGranter := false + granterKey, err := prov.KeyFromKeyOrAddress(granterKeyOrAddr) if err != nil { - return fmt.Errorf("could not get granter key from '%s'", granterKeyOrAddr) + externalGranter = true + } + + if externalGranter { + _, err := prov.DecodeBech32AccAddr(granterKeyOrAddr) + if err != nil { + return fmt.Errorf("an unknown granter was specified: '%s' is not a valid bech32 address", granterKeyOrAddr) + } } if delete { - fmt.Printf("Deleting %s feegrant configuration\n", chain) + a.log.Info("Deleting feegrant configuration", zap.String("chain", chain)) cfgErr := a.performConfigLockingOperation(cmd.Context(), func() error { chain := a.config.Chains[chain] @@ -75,11 +87,12 @@ func feegrantConfigureBasicCmd(a *appState) *cobra.Command { return nil } - if prov.PCfg.FeeGrants != nil && granterKey != prov.PCfg.FeeGrants.GranterKey && !update { - return fmt.Errorf("you specified granter '%s' which is different than configured feegranter '%s', but you did not specify the --overwrite-granter flag", granterKeyOrAddr, prov.PCfg.FeeGrants.GranterKey) - } else if prov.PCfg.FeeGrants != nil && granterKey != prov.PCfg.FeeGrants.GranterKey && update { + if prov.PCfg.FeeGrants != nil && granterKey != prov.PCfg.FeeGrants.GranterKeyOrAddr && !update { + return fmt.Errorf("you specified granter '%s' which is different than configured feegranter '%s', but you did not specify the --overwrite-granter flag", granterKeyOrAddr, prov.PCfg.FeeGrants.GranterKeyOrAddr) + } else if prov.PCfg.FeeGrants != nil && granterKey != prov.PCfg.FeeGrants.GranterKeyOrAddr && update { cfgErr := a.performConfigLockingOperation(cmd.Context(), func() error { - prov.PCfg.FeeGrants.GranterKey = granterKey + prov.PCfg.FeeGrants.GranterKeyOrAddr = granterKey + prov.PCfg.FeeGrants.IsExternalGranter = externalGranter return nil }) cobra.CheckErr(cfgErr) @@ -88,11 +101,16 @@ func feegrantConfigureBasicCmd(a *appState) *cobra.Command { if prov.PCfg.FeeGrants == nil || updateGrantees || len(grantees) > 0 { var feegrantErr error - //No list of grantees was provided, so we will use the default naming convention "grantee1, ... granteeN" + // No list of grantees was provided, so we will use the default naming convention "grantee1, ... granteeN" if grantees == nil { + if externalGranter { + return fmt.Errorf("external granter %s was specified, pre-authorized grantees must also be specified", granterKeyOrAddr) + } feegrantErr = prov.ConfigureFeegrants(numGrantees, granterKey) - } else { + } else if !externalGranter { feegrantErr = prov.ConfigureWithGrantees(grantees, granterKey) + } else { + feegrantErr = prov.ConfigureWithExternalGranter(grantees, granterKeyOrAddr) } if feegrantErr != nil { @@ -102,6 +120,7 @@ func feegrantConfigureBasicCmd(a *appState) *cobra.Command { cfgErr := a.performConfigLockingOperation(cmd.Context(), func() error { chain := a.config.Chains[chain] oldProv := chain.ChainProvider.(*cosmos.CosmosProvider) + prov.PCfg.FeeGrants.IsExternalGranter = externalGranter oldProv.PCfg.FeeGrants = prov.PCfg.FeeGrants return nil }) @@ -113,25 +132,32 @@ func feegrantConfigureBasicCmd(a *appState) *cobra.Command { return err } + gas := uint64(0) + gasStr, _ := cmd.Flags().GetString(sdkflags.FlagGas) + if gasStr != "" { + gasSetting, _ := sdkflags.ParseGasSetting(gasStr) + gas = gasSetting.Gas + } + ctx := cmd.Context() - _, err = prov.EnsureBasicGrants(ctx, memo) + _, err = prov.EnsureBasicGrants(ctx, memo, gas) if err != nil { return fmt.Errorf("error writing grants on chain: '%s'", err.Error()) } - //Get latest height from the chain, mark feegrant configuration as verified up to that height. - //This means we've verified feegranting is enabled on-chain and TXs can be sent with a feegranter. + // Get latest height from the chain, mark feegrant configuration as verified up to that height. + // This means we've verified feegranting is enabled on-chain and TXs can be sent with a feegranter. if prov.PCfg.FeeGrants != nil { - fmt.Printf("Querying latest chain height to mark FeeGrant height... \n") h, err := prov.QueryLatestHeight(ctx) cobra.CheckErr(err) cfgErr := a.performConfigLockingOperation(cmd.Context(), func() error { chain := a.config.Chains[chain] oldProv := chain.ChainProvider.(*cosmos.CosmosProvider) + prov.PCfg.FeeGrants.IsExternalGranter = externalGranter oldProv.PCfg.FeeGrants = prov.PCfg.FeeGrants oldProv.PCfg.FeeGrants.BlockHeightVerified = h - fmt.Printf("Feegrant chain height marked: %d\n", h) + a.log.Info("feegrant configured", zap.Int64("height", h)) return nil }) cobra.CheckErr(cfgErr) @@ -147,6 +173,7 @@ func feegrantConfigureBasicCmd(a *appState) *cobra.Command { cmd.Flags().IntVar(&numGrantees, "num-grantees", 10, "number of grantees that will be feegranted with basic allowances") cmd.Flags().StringSliceVar(&grantees, "grantees", nil, "comma separated list of grantee key names (keys are created if they do not exist)") cmd.MarkFlagsMutuallyExclusive("num-grantees", "grantees", "delete") + cmd.Flags().String(sdkflags.FlagGas, "", fmt.Sprintf("gas limit to set per-transaction; set to %q to calculate sufficient gas automatically (default %d)", sdkflags.GasFlagAuto, sdkflags.DefaultGasLimit)) memoFlag(a.viper, cmd) return cmd @@ -169,18 +196,6 @@ func feegrantBasicGrantsCmd(a *appState) *cobra.Command { return errors.New("only CosmosProvider can be feegranted") } - // TODO fix pagination - // pageReq, err := client.ReadPageRequest(cmd.Flags()) - // if err != nil { - // return err - // } - - //TODO fix height - // height, err := lensCmd.ReadHeight(cmd.Flags()) - // if err != nil { - // return err - // } - keyNameOrAddress := "" if len(args) == 0 { keyNameOrAddress = prov.PCfg.Key @@ -190,7 +205,7 @@ func feegrantBasicGrantsCmd(a *appState) *cobra.Command { granterAcc, err := prov.AccountFromKeyOrAddress(keyNameOrAddress) if err != nil { - fmt.Printf("Error retrieving account from key '%s'\n", keyNameOrAddress) + a.log.Error("Unknown account", zap.String("key_or_address", keyNameOrAddress), zap.Error(err)) return err } granterAddr := prov.MustEncodeAccAddr(granterAcc) @@ -203,7 +218,7 @@ func feegrantBasicGrantsCmd(a *appState) *cobra.Command { for _, grant := range res { allowance, e := prov.Sprint(grant.Allowance) cobra.CheckErr(e) - fmt.Printf("Granter: %s, Grantee: %s, Allowance: %s\n", grant.Granter, grant.Grantee, allowance) + a.log.Info("feegrant", zap.String("granter", grant.Granter), zap.String("grantee", grant.Grantee), zap.String("allowance", allowance)) } return nil diff --git a/cmd/flags.go b/cmd/flags.go index f4d2011a2..90b6eeb87 100644 --- a/cmd/flags.go +++ b/cmd/flags.go @@ -6,71 +6,65 @@ import ( "github.com/cosmos/relayer/v2/relayer" "github.com/cosmos/relayer/v2/relayer/processor" - "github.com/spf13/cobra" "github.com/spf13/viper" ) const ( - flagHome = "home" - flagURL = "url" - flagSkip = "skip" - flagTimeout = "timeout" - flagJSON = "json" - flagYAML = "yaml" - flagFile = "file" - flagForceAdd = "force-add" - flagPath = "path" - flagTestnet = "testnet" - flagMaxTxSize = "max-tx-size" - flagMaxMsgLength = "max-msgs" - flagIBCDenoms = "ibc-denoms" - flagTimeoutHeightOffset = "timeout-height-offset" - flagTimeoutTimeOffset = "timeout-time-offset" - flagMaxRetries = "max-retries" - flagThresholdTime = "time-threshold" - flagUpdateAfterExpiry = "update-after-expiry" - flagUpdateAfterMisbehaviour = "update-after-misbehaviour" - flagClientTrustingPeriod = "client-tp" - flagClientUnbondingPeriod = "client-unbonding-period" - flagOverride = "override" - flagSrcPort = "src-port" - flagDstPort = "dst-port" - flagOrder = "order" - flagVersion = "version" - flagDebugAddr = "debug-addr" - flagOverwriteConfig = "overwrite" - flagLimit = "limit" - flagHeight = "height" - flagPage = "page" - flagPageKey = "page-key" - flagCountTotal = "count-total" - flagReverse = "reverse" - flagProcessor = "processor" - flagInitialBlockHistory = "block-history" - flagFlushInterval = "flush-interval" - flagMemo = "memo" - flagFilterRule = "filter-rule" - flagFilterChannels = "filter-channels" - flagSrcChainID = "src-chain-id" - flagDstChainID = "dst-chain-id" - flagSrcClientID = "src-client-id" - flagDstClientID = "dst-client-id" - flagSrcConnID = "src-connection-id" - flagDstConnID = "dst-connection-id" - flagOutput = "output" - flagStuckPacketChainID = "stuck-packet-chain-id" - flagStuckPacketHeightStart = "stuck-packet-height-start" - flagStuckPacketHeightEnd = "stuck-packet-height-end" + flagHome = "home" + flagURL = "url" + flagSkip = "skip" + flagTimeout = "timeout" + flagJSON = "json" + flagYAML = "yaml" + flagFile = "file" + flagForceAdd = "force-add" + flagPath = "path" + flagTestnet = "testnet" + flagMaxMsgLength = "max-msgs" + flagIBCDenoms = "ibc-denoms" + flagTimeoutHeightOffset = "timeout-height-offset" + flagTimeoutTimeOffset = "timeout-time-offset" + flagMaxRetries = "max-retries" + flagThresholdTime = "time-threshold" + flagUpdateAfterExpiry = "update-after-expiry" + flagUpdateAfterMisbehaviour = "update-after-misbehaviour" + flagClientTrustingPeriod = "client-tp" + flagClientUnbondingPeriod = "client-unbonding-period" + flagClientTrustingPeriodPercentage = "client-tp-percentage" + flagMaxClockDrift = "max-clock-drift" + flagOverride = "override" + flagSrcPort = "src-port" + flagDstPort = "dst-port" + flagOrder = "order" + flagVersion = "version" + flagDebugAddr = "debug-addr" + flagOverwriteConfig = "overwrite" + flagLimit = "limit" + flagHeight = "height" + flagPage = "page" + flagPageKey = "page-key" + flagCountTotal = "count-total" + flagReverse = "reverse" + flagProcessor = "processor" + flagInitialBlockHistory = "block-history" + flagFlushInterval = "flush-interval" + flagMemo = "memo" + flagFilterRule = "filter-rule" + flagFilterChannels = "filter-channels" + flagSrcChainID = "src-chain-id" + flagDstChainID = "dst-chain-id" + flagSrcClientID = "src-client-id" + flagDstClientID = "dst-client-id" + flagSrcConnID = "src-connection-id" + flagDstConnID = "dst-connection-id" + flagOutput = "output" + flagStuckPacketChainID = "stuck-packet-chain-id" + flagStuckPacketHeightStart = "stuck-packet-height-start" + flagStuckPacketHeightEnd = "stuck-packet-height-end" ) -const ( - // 7597 is "RLYR" on a telephone keypad. - // It also happens to be unassigned in the IANA port list. - defaultDebugAddr = "localhost:7597" - - blankValue = "blank" -) +const blankValue = "blank" func ibcDenomFlags(v *viper.Viper, cmd *cobra.Command) *cobra.Command { cmd.Flags().BoolP(flagIBCDenoms, "i", false, "Display IBC denominations for sending tokens back to other chains") @@ -89,7 +83,14 @@ func heightFlag(v *viper.Viper, cmd *cobra.Command) *cobra.Command { } func paginationFlags(v *viper.Viper, cmd *cobra.Command, query string) *cobra.Command { - cmd.Flags().Uint64(flagPage, 1, fmt.Sprintf("pagination page of %s to query for. This sets offset to a multiple of limit", query)) + cmd.Flags().Uint64( + flagPage, + 1, + fmt.Sprintf("pagination page of %s to query for. This sets offset to a multiple of limit", + query, + ), + ) + cmd.Flags().String(flagPageKey, "", fmt.Sprintf("pagination page-key of %s to query for", query)) cmd.Flags().Uint64(flagLimit, 100, fmt.Sprintf("pagination limit of %s to query for", query)) cmd.Flags().Bool(flagCountTotal, false, fmt.Sprintf("count total number of records in %s to query for", query)) @@ -304,10 +305,15 @@ func retryFlag(v *viper.Viper, cmd *cobra.Command) *cobra.Command { } func updateTimeFlags(v *viper.Viper, cmd *cobra.Command) *cobra.Command { - cmd.Flags().Duration(flagThresholdTime, relayer.DefaultClientUpdateThreshold, "time after previous client update before automatic client update") + cmd.Flags().Duration( + flagThresholdTime, + relayer.DefaultClientUpdateThreshold, + "time after previous client update before automatic client update", + ) if err := v.BindPFlag(flagThresholdTime, cmd.Flags().Lookup(flagThresholdTime)); err != nil { panic(err) } + return cmd } @@ -316,16 +322,38 @@ func clientParameterFlags(v *viper.Viper, cmd *cobra.Command) *cobra.Command { "allow governance to update the client if expiry occurs") cmd.Flags().BoolP(flagUpdateAfterMisbehaviour, "m", true, "allow governance to update the client if misbehaviour freezing occurs") - cmd.Flags().Duration(flagClientTrustingPeriod, 0, "custom light client trusting period ex. 24h (default: 85% of chains reported unbonding time)") + cmd.Flags().Duration( + flagClientTrustingPeriod, + 0, + "custom light client trusting period ex. 24h (default: 85% of chains reported unbonding time)`", + ) + cmd.Flags().Int64( + flagClientTrustingPeriodPercentage, + 85, + "custom light client trusting period percentage ex. 66 (default: 85); this flag overrides the client-tp flag", + ) + cmd.Flags().Duration(flagMaxClockDrift, (10 * time.Minute), + "custom max clock drift for client(s)") + if err := v.BindPFlag(flagUpdateAfterExpiry, cmd.Flags().Lookup(flagUpdateAfterExpiry)); err != nil { panic(err) } + if err := v.BindPFlag(flagUpdateAfterMisbehaviour, cmd.Flags().Lookup(flagUpdateAfterMisbehaviour)); err != nil { panic(err) } + if err := v.BindPFlag(flagClientTrustingPeriod, cmd.Flags().Lookup(flagClientTrustingPeriod)); err != nil { panic(err) } + + if err := v.BindPFlag(flagMaxClockDrift, cmd.Flags().Lookup(flagMaxClockDrift)); err != nil { + panic(err) + } + if err := v.BindPFlag(flagClientTrustingPeriodPercentage, cmd.Flags().Lookup(flagClientTrustingPeriodPercentage)); err != nil { + panic(err) + } + return cmd } @@ -334,10 +362,17 @@ func channelParameterFlags(v *viper.Viper, cmd *cobra.Command) *cobra.Command { } func clientUnbondingPeriodFlag(v *viper.Viper, cmd *cobra.Command) *cobra.Command { - cmd.Flags().Duration(flagClientUnbondingPeriod, 0, "custom unbonding period for client state. This is useful when you need to create a new client matching an older client state") + cmd.Flags().Duration( + flagClientUnbondingPeriod, + 0, + "custom unbonding period for client state. This is useful when you need to create a new client matching "+ + "an older client state", + ) + if err := v.BindPFlag(flagClientUnbondingPeriod, cmd.Flags().Lookup(flagClientUnbondingPeriod)); err != nil { panic(err) } + return cmd } @@ -382,10 +417,17 @@ func dstPortFlag(v *viper.Viper, cmd *cobra.Command) *cobra.Command { } func debugServerFlags(v *viper.Viper, cmd *cobra.Command) *cobra.Command { - cmd.Flags().String(flagDebugAddr, "", "address to use for debug and metrics server. By default, will be the api-listen-addr parameter in the global config.") + cmd.Flags().String( + flagDebugAddr, + "", + "address to use for debug and metrics server. By default, "+ + "will be the api-listen-addr parameter in the global config.", + ) + if err := v.BindPFlag(flagDebugAddr, cmd.Flags().Lookup(flagDebugAddr)); err != nil { panic(err) } + return cmd } @@ -398,18 +440,32 @@ func processorFlag(v *viper.Viper, cmd *cobra.Command) *cobra.Command { } func initBlockFlag(v *viper.Viper, cmd *cobra.Command) *cobra.Command { - cmd.Flags().Uint64P(flagInitialBlockHistory, "b", 20, "initial block history to query when using 'events' as the processor for relaying") + cmd.Flags().Uint64P( + flagInitialBlockHistory, + "b", + 20, + "initial block history to query when using 'events' as the processor for relaying", + ) + if err := v.BindPFlag(flagInitialBlockHistory, cmd.Flags().Lookup(flagInitialBlockHistory)); err != nil { panic(err) } + return cmd } func flushIntervalFlag(v *viper.Viper, cmd *cobra.Command) *cobra.Command { - cmd.Flags().DurationP(flagFlushInterval, "i", relayer.DefaultFlushInterval, "how frequently should a flush routine be run") + cmd.Flags().DurationP( + flagFlushInterval, + "i", + relayer.DefaultFlushInterval, + "how frequently should a flush routine be run", + ) + if err := v.BindPFlag(flagFlushInterval, cmd.Flags().Lookup(flagFlushInterval)); err != nil { panic(err) } + return cmd } @@ -483,7 +539,11 @@ func parseStuckPacketFromFlags(cmd *cobra.Command) (*processor.StuckPacket, erro } if stuckPacketHeightEnd < stuckPacketHeightStart { - return nil, fmt.Errorf("stuck packet end height %d is less than start height %d", stuckPacketHeightEnd, stuckPacketHeightStart) + return nil, fmt.Errorf( + "stuck packet end height %d is less than start height %d", + stuckPacketHeightEnd, + stuckPacketHeightStart, + ) } return &processor.StuckPacket{ diff --git a/cmd/query.go b/cmd/query.go index 2f3c2e3e9..648cd725d 100644 --- a/cmd/query.go +++ b/cmd/query.go @@ -9,7 +9,7 @@ import ( "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/types/query" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer" "github.com/cosmos/relayer/v2/relayer/chains/cosmos" "github.com/spf13/cobra" diff --git a/cmd/root.go b/cmd/root.go index 1a6cfc3d3..52e316055 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -73,17 +73,15 @@ func NewRootCmd(log *zap.Logger) *cobra.Command { rootCmd.PersistentPreRunE = func(cmd *cobra.Command, _ []string) error { // Inside persistent pre-run because this takes effect after flags are parsed. - if log == nil { - log, err := newRootLogger(a.viper.GetString("log-format"), a.viper.GetBool("debug")) - if err != nil { - return err - } - - a.log = log - } - // reads `homeDir/config/config.yaml` into `a.Config` - return a.loadConfigFile(rootCmd.Context()) + if err := a.loadConfigFile(rootCmd.Context()); err != nil { + return err + } + // Inside persistent pre-run because this takes effect after flags are parsed. + if a.log == nil { + a.initLogger("") + } + return nil } rootCmd.PersistentPostRun = func(cmd *cobra.Command, _ []string) { @@ -108,6 +106,12 @@ func NewRootCmd(log *zap.Logger) *cobra.Command { panic(err) } + // Register --log-level flag + rootCmd.PersistentFlags().String("log-level", "", "log level format (info, debug, warn, error, panic or fatal)") + if err := a.viper.BindPFlag("log-level", rootCmd.PersistentFlags().Lookup("log-level")); err != nil { + panic(err) + } + // Register subcommands rootCmd.AddCommand( configCmd(a), @@ -171,7 +175,7 @@ func Execute() { } } -func newRootLogger(format string, debug bool) (*zap.Logger, error) { +func newRootLogger(format string, logLevel string) (*zap.Logger, error) { config := zap.NewProductionEncoderConfig() config.EncodeTime = func(ts time.Time, encoder zapcore.PrimitiveArrayEncoder) { encoder.AppendString(ts.UTC().Format("2006-01-02T15:04:05.000000Z07:00")) @@ -191,8 +195,17 @@ func newRootLogger(format string, debug bool) (*zap.Logger, error) { } level := zap.InfoLevel - if debug { + switch logLevel { + case "debug": level = zap.DebugLevel + case "warn": + level = zapcore.WarnLevel + case "error": + level = zapcore.ErrorLevel + case "panic": + level = zapcore.PanicLevel + case "fatal": + level = zapcore.FatalLevel } return zap.New(zapcore.NewCore( enc, diff --git a/cmd/start.go b/cmd/start.go index 42e4c62ee..c508f8732 100644 --- a/cmd/start.go +++ b/cmd/start.go @@ -110,7 +110,12 @@ $ %s start demo-path2 --max-tx-size 10`, appName, appName, appName, appName)), } else { ln, err := net.Listen("tcp", debugAddr) if err != nil { - a.log.Error("Failed to listen on debug address. If you have another relayer process open, use --" + flagDebugAddr + " to pick a different address.") + a.log.Error( + "Failed to listen on debug address. If you have another relayer process open, use --" + + flagDebugAddr + + " to pick a different address.", + ) + return fmt.Errorf("failed to listen on debug address %q: %w", debugAddr, err) } log := a.log.With(zap.String("sys", "debughttp")) @@ -128,6 +133,7 @@ $ %s start demo-path2 --max-tx-size 10`, appName, appName, appName, appName)), if err != nil { return err } + initialBlockHistory, err := cmd.Flags().GetUint64(flagInitialBlockHistory) if err != nil { return err @@ -154,6 +160,8 @@ $ %s start demo-path2 --max-tx-size 10`, appName, appName, appName, appName)), chains, paths, maxMsgLength, + a.config.Global.MaxReceiverSize, + a.config.Global.ICS20MemoLimit, a.config.memo(cmd), clientUpdateThresholdTime, flushInterval, diff --git a/cmd/tx.go b/cmd/tx.go index bb59ec645..47f37a41d 100644 --- a/cmd/tx.go +++ b/cmd/tx.go @@ -8,8 +8,9 @@ import ( "time" "github.com/avast/retry-go/v4" + sdk "github.com/cosmos/cosmos-sdk/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" @@ -79,6 +80,16 @@ func createClientsCmd(a *appState) *cobra.Command { return err } + maxClockDrift, err := cmd.Flags().GetDuration(flagMaxClockDrift) + if err != nil { + return err + } + + customClientTrustingPeriodPercentage, err := cmd.Flags().GetInt64(flagClientTrustingPeriodPercentage) + if err != nil { + return err + } + override, err := cmd.Flags().GetBool(flagOverride) if err != nil { return err @@ -99,10 +110,21 @@ func createClientsCmd(a *appState) *cobra.Command { return fmt.Errorf("key %s not found on dst chain %s", c[dst].ChainProvider.Key(), c[dst].ChainID()) } - clientSrc, clientDst, err := c[src].CreateClients(cmd.Context(), c[dst], allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, override, customClientTrustingPeriod, a.config.memo(cmd)) + clientSrc, clientDst, err := c[src].CreateClients( + cmd.Context(), + c[dst], + allowUpdateAfterExpiry, + allowUpdateAfterMisbehaviour, + override, + customClientTrustingPeriod, + maxClockDrift, + customClientTrustingPeriodPercentage, + a.config.memo(cmd), + ) if err != nil { return err } + if clientSrc != "" || clientDst != "" { if err := a.updatePathConfig(cmd.Context(), path, clientSrc, clientDst, "", ""); err != nil { return err @@ -143,6 +165,11 @@ func createClientCmd(a *appState) *cobra.Command { return err } + customClientTrustingPeriodPercentage, err := cmd.Flags().GetInt64(flagClientTrustingPeriodPercentage) + if err != nil { + return err + } + overrideUnbondingPeriod, err := cmd.Flags().GetDuration(flagClientUnbondingPeriod) if err != nil { return err @@ -153,10 +180,16 @@ func createClientCmd(a *appState) *cobra.Command { return err } + maxClockDrift, err := cmd.Flags().GetDuration(flagMaxClockDrift) + if err != nil { + return err + } + src, ok := a.config.Chains[args[0]] if !ok { return errChainNotFound(args[0]) } + dst, ok := a.config.Chains[args[1]] if !ok { return errChainNotFound(args[1]) @@ -175,6 +208,7 @@ func createClientCmd(a *appState) *cobra.Command { if exists := src.ChainProvider.KeyExists(src.ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on src chain %s", src.ChainProvider.Key(), src.ChainID()) } + if exists := dst.ChainProvider.KeyExists(dst.ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on dst chain %s", dst.ChainProvider.Key(), dst.ChainID()) } @@ -199,32 +233,51 @@ func createClientCmd(a *appState) *cobra.Command { return err } return nil - }, retry.Context(cmd.Context()), relayer.RtyAtt, relayer.RtyDel, relayer.RtyErr, retry.OnRetry(func(n uint, err error) { - a.log.Info( - "Failed to get light signed header", - zap.String("src_chain_id", src.ChainID()), - zap.Int64("src_height", srch), - zap.String("dst_chain_id", dst.ChainID()), - zap.Int64("dst_height", dsth), - zap.Uint("attempt", n+1), - zap.Uint("max_attempts", relayer.RtyAttNum), - zap.Error(err), - ) - srch, dsth, _ = relayer.QueryLatestHeights(cmd.Context(), src, dst) - })); err != nil { - return err - } - - clientID, err := relayer.CreateClient(cmd.Context(), src, dst, srcUpdateHeader, dstUpdateHeader, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, override, customClientTrustingPeriod, overrideUnbondingPeriod, a.config.memo(cmd)) + }, retry.Context( + cmd.Context()), + relayer.RtyAtt, + relayer.RtyDel, + relayer.RtyErr, + retry.OnRetry(func(n uint, err error) { + a.log.Info( + "Failed to get light signed header", + zap.String("src_chain_id", src.ChainID()), + zap.Int64("src_height", srch), + zap.String("dst_chain_id", dst.ChainID()), + zap.Int64("dst_height", dsth), + zap.Uint("attempt", n+1), + zap.Uint("max_attempts", relayer.RtyAttNum), + zap.Error(err), + ) + srch, dsth, _ = relayer.QueryLatestHeights(cmd.Context(), src, dst) + })); err != nil { + return err + } + + clientID, err := relayer.CreateClient( + cmd.Context(), + src, dst, + srcUpdateHeader, dstUpdateHeader, + allowUpdateAfterExpiry, + allowUpdateAfterMisbehaviour, + override, + customClientTrustingPeriod, + overrideUnbondingPeriod, + maxClockDrift, + customClientTrustingPeriodPercentage, + a.config.memo(cmd), + ) if err != nil { return err } + var clientSrc, clientDst string if path.Src.ChainID == src.ChainID() { clientSrc = clientID } else { clientDst = clientID } + if clientID != "" { if err = a.updatePathConfig(cmd.Context(), pathName, clientSrc, clientDst, "", ""); err != nil { return err @@ -261,6 +314,7 @@ corresponding update-client messages.`, if exists := c[src].ChainProvider.KeyExists(c[src].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on src chain %s", c[src].ChainProvider.Key(), c[src].ChainID()) } + if exists := c[dst].ChainProvider.KeyExists(c[dst].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on dst chain %s", c[dst].ChainProvider.Key(), c[dst].ChainID()) } @@ -292,6 +346,7 @@ func upgradeClientsCmd(a *appState) *cobra.Command { if exists := c[src].ChainProvider.KeyExists(c[src].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on src chain %s", c[src].ChainProvider.Key(), c[src].ChainID()) } + if exists := c[dst].ChainProvider.KeyExists(c[dst].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on dst chain %s", c[dst].ChainProvider.Key(), c[dst].ChainID()) } @@ -318,7 +373,7 @@ func createConnectionCmd(a *appState) *cobra.Command { cmd := &cobra.Command{ Use: "connection path_name", Aliases: []string{"conn"}, - Short: "create a connection between two configured chains with a configured path", + Short: "create a connection between two configured chains with a configured path; if existing client does not exist, it will create one", Long: strings.TrimSpace(`Create or repair a connection between two IBC-connected networks along a specific path.`, ), @@ -344,6 +399,11 @@ $ %s tx conn demo-path --timeout 5s`, return err } + customClientTrustingPeriodPercentage, err := cmd.Flags().GetInt64(flagClientTrustingPeriodPercentage) + if err != nil { + return err + } + pathName := args[0] c, src, dst, err := a.config.ChainsFromPath(pathName) @@ -366,10 +426,16 @@ $ %s tx conn demo-path --timeout 5s`, return err } + maxClockDrift, err := cmd.Flags().GetDuration(flagMaxClockDrift) + if err != nil { + return err + } + // ensure that keys exist if exists := c[src].ChainProvider.KeyExists(c[src].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on src chain %s", c[src].ChainProvider.Key(), c[src].ChainID()) } + if exists := c[dst].ChainProvider.KeyExists(c[dst].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on dst chain %s", c[dst].ChainProvider.Key(), c[dst].ChainID()) } @@ -382,20 +448,40 @@ $ %s tx conn demo-path --timeout 5s`, } // ensure that the clients exist - clientSrc, clientDst, err := c[src].CreateClients(cmd.Context(), c[dst], allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, override, customClientTrustingPeriod, memo) + clientSrc, clientDst, err := c[src].CreateClients( + cmd.Context(), + c[dst], + allowUpdateAfterExpiry, + allowUpdateAfterMisbehaviour, + override, + customClientTrustingPeriod, + maxClockDrift, + customClientTrustingPeriodPercentage, + memo, + ) if err != nil { return err } + if clientSrc != "" || clientDst != "" { if err := a.updatePathConfig(cmd.Context(), pathName, clientSrc, clientDst, "", ""); err != nil { return err } } - connectionSrc, connectionDst, err := c[src].CreateOpenConnections(cmd.Context(), c[dst], retries, to, memo, initialBlockHistory, pathName) + connectionSrc, connectionDst, err := c[src].CreateOpenConnections( + cmd.Context(), + c[dst], + retries, + to, + memo, + initialBlockHistory, + pathName, + ) if err != nil { return err } + if connectionSrc != "" || connectionDst != "" { if err := a.updatePathConfig(cmd.Context(), pathName, "", "", connectionSrc, connectionDst); err != nil { return err @@ -419,7 +505,8 @@ func createChannelCmd(a *appState) *cobra.Command { cmd := &cobra.Command{ Use: "channel path_name", Aliases: []string{"chan"}, - Short: "create a channel between two configured chains with a configured path using specified or default channel identifiers", + Short: "create a channel between two configured chains with a configured path using specified or " + + "default channel identifiers", Long: strings.TrimSpace(`Create or repair a channel between two IBC-connected networks along a specific path.`, ), @@ -430,7 +517,6 @@ $ %s tx chan demo-path --timeout 5s --max-retries 10`, appName, appName, )), RunE: func(cmd *cobra.Command, args []string) error { - pathName := args[0] c, src, dst, err := a.config.ChainsFromPath(pathName) @@ -477,12 +563,25 @@ $ %s tx chan demo-path --timeout 5s --max-retries 10`, if exists := c[src].ChainProvider.KeyExists(c[src].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on src chain %s", c[src].ChainProvider.Key(), c[src].ChainID()) } + if exists := c[dst].ChainProvider.KeyExists(c[dst].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on dst chain %s", c[dst].ChainProvider.Key(), c[dst].ChainID()) } // create channel if it isn't already created - return c[src].CreateOpenChannels(cmd.Context(), c[dst], retries, to, srcPort, dstPort, order, version, override, a.config.memo(cmd), pathName) + return c[src].CreateOpenChannels( + cmd.Context(), + c[dst], + retries, + to, + srcPort, + dstPort, + order, + version, + override, + a.config.memo(cmd), + pathName, + ) }, } @@ -531,6 +630,7 @@ $ %s tx channel-close demo-path channel-0 transfer -o 3s`, if exists := c[src].ChainProvider.KeyExists(c[src].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on src chain %s", c[src].ChainProvider.Key(), c[src].ChainID()) } + if exists := c[dst].ChainProvider.KeyExists(c[dst].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on dst chain %s", c[dst].ChainProvider.Key(), c[dst].ChainID()) } @@ -586,6 +686,11 @@ $ %s tx connect demo-path --src-port transfer --dst-port transfer --order unorde return err } + customClientTrustingPeriodPercentage, err := cmd.Flags().GetInt64(flagClientTrustingPeriodPercentage) + if err != nil { + return err + } + pathName := args[0] pth, err := a.config.Paths.Get(pathName) @@ -637,10 +742,16 @@ $ %s tx connect demo-path --src-port transfer --dst-port transfer --order unorde return err } + maxClockDrift, err := cmd.Flags().GetDuration(flagMaxClockDrift) + if err != nil { + return err + } + // ensure that keys exist if exists := c[src].ChainProvider.KeyExists(c[src].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on src chain %s", c[src].ChainProvider.Key(), c[src].ChainID()) } + if exists := c[dst].ChainProvider.KeyExists(c[dst].ChainProvider.Key()); !exists { return fmt.Errorf("key %s not found on dst chain %s", c[dst].ChainProvider.Key(), c[dst].ChainID()) } @@ -653,10 +764,21 @@ $ %s tx connect demo-path --src-port transfer --dst-port transfer --order unorde } // create clients if they aren't already created - clientSrc, clientDst, err := c[src].CreateClients(cmd.Context(), c[dst], allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, override, customClientTrustingPeriod, memo) + clientSrc, clientDst, err := c[src].CreateClients( + cmd.Context(), + c[dst], + allowUpdateAfterExpiry, + allowUpdateAfterMisbehaviour, + override, + customClientTrustingPeriod, + maxClockDrift, + customClientTrustingPeriodPercentage, + memo, + ) if err != nil { return fmt.Errorf("error creating clients: %w", err) } + if clientSrc != "" || clientDst != "" { if err := a.updatePathConfig(cmd.Context(), pathName, clientSrc, clientDst, "", ""); err != nil { return err @@ -664,10 +786,19 @@ $ %s tx connect demo-path --src-port transfer --dst-port transfer --order unorde } // create connection if it isn't already created - connectionSrc, connectionDst, err := c[src].CreateOpenConnections(cmd.Context(), c[dst], retries, to, memo, initialBlockHistory, pathName) + connectionSrc, connectionDst, err := c[src].CreateOpenConnections( + cmd.Context(), + c[dst], + retries, + to, + memo, + initialBlockHistory, + pathName, + ) if err != nil { return fmt.Errorf("error creating connections: %w", err) } + if connectionSrc != "" || connectionDst != "" { if err := a.updatePathConfig(cmd.Context(), pathName, "", "", connectionSrc, connectionDst); err != nil { return err @@ -675,7 +806,19 @@ $ %s tx connect demo-path --src-port transfer --dst-port transfer --order unorde } // create channel if it isn't already created - return c[src].CreateOpenChannels(cmd.Context(), c[dst], retries, to, srcPort, dstPort, order, version, override, memo, pathName) + return c[src].CreateOpenChannels( + cmd.Context(), + c[dst], + retries, + to, + srcPort, + dstPort, + order, + version, + override, + memo, + pathName, + ) }, } cmd = timeoutFlag(a.viper, cmd) @@ -815,6 +958,8 @@ $ %s tx flush demo-path channel-0`, chains, paths, maxMsgLength, + a.config.Global.MaxReceiverSize, + a.config.Global.ICS20MemoLimit, a.config.memo(cmd), 0, 0, @@ -909,6 +1054,7 @@ $ %s tx raw send ibc-0 ibc-1 100000stake cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9 if !ok { return errChainNotFound(args[0]) } + dst, ok := a.config.Chains[args[1]] if !ok { return errChainNotFound(args[1]) @@ -938,11 +1084,12 @@ $ %s tx raw send ibc-0 ibc-1 100000stake cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9 srcChannelID := args[4] var pathConnectionID string - if src.ChainID() == path.Src.ChainID { + switch { + case src.ChainID() == path.Src.ChainID: pathConnectionID = path.Src.ConnectionID - } else if src.ChainID() == path.Dst.ChainID { + case src.ChainID() == path.Dst.ChainID: pathConnectionID = path.Dst.ConnectionID - } else { + default: return fmt.Errorf("no path configured using chain-id: %s", src.ChainID()) } @@ -995,10 +1142,23 @@ $ %s tx raw send ibc-0 ibc-1 100000stake cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9 dstAddr = rawDstAddr } - return src.SendTransferMsg(cmd.Context(), a.log, dst, amount, dstAddr, toHeightOffset, toTimeOffset, srcChannel) + memo := a.config.memo(cmd) + + return src.SendTransferMsg( + cmd.Context(), + a.log, + dst, + amount, + dstAddr, + memo, + toHeightOffset, + toTimeOffset, + srcChannel, + ) }, } + cmd = memoFlag(a.viper, cmd) return timeoutFlags(a.viper, pathFlag(a.viper, cmd)) } @@ -1062,11 +1222,11 @@ func registerCounterpartyCmd(a *appState) *cobra.Command { Short: "register the counterparty relayer address for ics-29 fee middleware", Args: withUsage(cobra.MatchAll(cobra.ExactArgs(5))), Example: strings.TrimSpace(fmt.Sprintf(` -$ %s register-counterparty channel-1 transfer cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9nf39lk juno1g0ny488ws4064mjjxk4keenwfjrthn503ngjxd +$ %s register-counterparty channel-1 transfer cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9nf39lk +juno1g0ny488ws4064mjjxk4keenwfjrthn503ngjxd $ %s reg-cpt channel-1 cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9nf39lk juno1g0ny488ws4064mjjxk4keenwfjrthn503ngjxd`, appName, appName)), RunE: func(cmd *cobra.Command, args []string) error { - chain, ok := a.config.Chains[args[0]] if !ok { return errChainNotFound(args[0]) @@ -1082,10 +1242,15 @@ $ %s reg-cpt channel-1 cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9nf39lk juno1g0ny48 if err != nil { return err } - res, success, err := chain.ChainProvider.SendMessage(cmd.Context(), msg, "") + + memo := a.config.memo(cmd) + + res, success, err := chain.ChainProvider.SendMessage(cmd.Context(), msg, memo) fmt.Println(res, success, err) + return nil }, } - return cmd + + return memoFlag(a.viper, cmd) } diff --git a/docs/advanced_usage.md b/docs/advanced_usage.md index 23e76e307..83230db62 100644 --- a/docs/advanced_usage.md +++ b/docs/advanced_usage.md @@ -12,15 +12,18 @@ Exported metrics: | **Exported Metric** | **Description** | **Type** | |:---------------------------------------------: |:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |:--------: | -| cosmos_relayer_observed_packets | The total number of observed packets | Counter | -| cosmos_relayer_relayed_packets | The total number of relayed packets | Counter | +| cosmos_relayer_observed_packets_total | The total number of observed packets | Counter | +| cosmos_relayer_relayed_packets_total | The total number of relayed packets | Counter | | cosmos_relayer_chain_latest_height | The current height of the chain | Gauge | | cosmos_relayer_wallet_balance | The current balance for the relayer's wallet | Gauge | | cosmos_relayer_fees_spent | The amount of fees spent from the relayer's wallet | Gauge | -| cosmos_relayer_tx_failure |
The total number of tx failures broken up into categories:
- "packet messages are redundant"
- "insufficient funds"
- "invalid coins"
- "out of gas"


"Tx Failure" is the the catch all bucket | Counter | -| cosmos_relayer_block_query_errors_total | The total number of block query failures. The failures are separated into two categories:
- "RPC Client"
- "IBC Header" | Counter | -| cosmos_relayer_client_expiration_seconds | Seconds until the client expires | Gauge | -| cosmos_relayer_client_trusting_period_seconds | The trusting period (in seconds) of the client | Gauge | +| cosmos_relayer_tx_failure |
The total number of tx failures broken up into categories:
- "packet messages are redundant"
- "insufficient funds"
- "invalid coins"
- "out of gas"


"Tx Failure" is the the catch all bucket | Counter | +| cosmos_relayer_block_query_errors_total | The total number of block query failures. The failures are separated into two categories:
- "RPC Client"
- "IBC Header" | Counter | +| cosmos_relayer_client_expiration_seconds | Seconds until the client expires | Gauge | +| cosmos_relayer_client_trusting_period_seconds | The trusting period (in seconds) of the client | Gauge | +| cosmos_relayer_unrelayed_packets | Current number of unrelayed packet sequences on a specific path and channel. This is updated after each flush (default is 5 min) | Gauge | +| cosmos_relayer_unrelayed_acks | Current number of unrelayed acknoledgment sequences on a specific path and channel. This is updated after each flush (default is 5 min) | Gauge | + @@ -65,6 +68,10 @@ For example, configure feegrants for Kujira: - Note: above, `default` is the key that will need to contain funds (the granter) - 10 grantees will be configured, so those 10 address will sign TXs in round robin order. +An external feegrant configuration can be applied with the following command: +- `rly chains configure feegrant basicallowance cosmoshub cosmosaddr --grantees grantee3` +- Note: above, `cosmosaddr` is a bech32 address that has already issued a feegrant allowance to `grantee3`. +- External configuration means that someone else controls `cosmosaddr` (you do not need the mnemonic). You may also choose to specify the exact names of your grantees: - `rly chains configure feegrant basicallowance kujira default --grantees "kuji1,kuji2,kuji3"` @@ -75,7 +82,6 @@ Rerunning the feegrant command will simply confirm your configuration is correct To remove the feegrant configuration: - `rly chains configure feegrant basicallowance kujira --delete` - ## Stuck Packet There can be scenarios where a standard flush fails to clear a packet due to differences in the way packets are observed. The standard flush depends on the packet queries working properly. Sometimes the packet queries can miss things that the block scanning performed by the relayer during standard operation wouldn't. For packets affected by this, if they were emitted in recent blocks, the `--block-history` flag can be used to have the standard relayer block scanning start at a block height that many blocks behind the current chain tip. However, if the stuck packet occurred at an old height, farther back than would be reasonable for the `--block-history` scan from historical to current, there is an additional set of flags that can be used to zoom in on the block heights where the stuck packet occurred. diff --git a/docs/create-path-across-chain.md b/docs/create-path-across-chain.md index 0aa90fc15..a0d9594bb 100644 --- a/docs/create-path-across-chain.md +++ b/docs/create-path-across-chain.md @@ -32,7 +32,9 @@ In our "Relaying Packets Across Chains" example, we set up the relayer to relay - `rly transact connection` - `rly transact channel` -
+
+ + One can add the ` --version "{\"fee_version\":\"ics29-1\",\"app_version\":\"ics20-1\"}" ` flag to the `link` transaction in order to create a channel that supports the [ICS-29](https://github.com/cosmos/ibc/tree/main/spec/app/ics-029-fee-payment) fee protocol standard. All the above commands will update your config with the new path meta-data EXCEPT the new channel-id, which will be printed in stdout. @@ -60,4 +62,4 @@ In our "Relaying Packets Across Chains" example, we set up the relayer to relay ![banner](./images/github-repo-banner.gif) -[<-- Home](../README.md) - [Advanced Usage -->](./advanced_usage.md) \ No newline at end of file +[<-- Home](../README.md) - [Advanced Usage -->](./advanced_usage.md) diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md index 75f46195e..10c35c739 100644 --- a/docs/troubleshooting.md +++ b/docs/troubleshooting.md @@ -1,7 +1,18 @@ # Troubleshooting +- [Generic Troubleshooting](#generic-troubleshoot) +- [Inspect Go Runtime Debug Data](#inspect-go-runtime-debug-data) +- [Specific Errors](#specific-errors) -**Ensure `rly` package is properly installed** +
+ +--- + +
+ +## Generic Troubleshooting + +### **Ensure `rly` package is properly installed** Run: ```shell @@ -10,9 +21,8 @@ If this returns an error, make sure you have Go installed and your Go environment is setup. Then redo [Step 1](#basic-usage---relaying-packets-across-chains). ---- -## **Verify valid `chain`, `client`, and `connection`** +### **Verify valid `keys`, `balance`, and `path`** ```shell $ rly chains list @@ -23,7 +33,7 @@ Output should show all checkboxes: -> type(cosmos) key(✔) bal(✔) path(✔) ``` -## **Verify valid `chain`, `client`, and `connection`** +### **Verify valid `chain`, `client`, and `connection`** ```shell $ rly paths list @@ -33,7 +43,7 @@ If output: ```shell -> chns(✘) clnts(✘) conn(✘) ``` -Verify that you have a healthy RPC address. +Verify that you have a healthy RPC address. This means the relayer was unable to query the latest height of one or both the chains. If: ```shell @@ -41,9 +51,19 @@ If: ``` Your client is the culprit here. Your client may be invalid or expired. +### **Ensure Client is not `expired`** + +```shell +$ rly query clients-expiration +``` + +
+ --- -## **Inspect Go runtime debug data** +
+ +## Inspect Go runtime debug data If you started `rly` with the default `--debug-addr` argument, you can open `http://localhost:7597` in your browser to explore details from the Go runtime. @@ -51,10 +71,18 @@ you can open `http://localhost:7597` in your browser to explore details from the If you need active assistance from the Relayer development team regarding an unresponsive Relayer instance, it will be helpful to provide the output from `http://localhost:7597/debug/pprof/goroutine?debug=2` at a minimum. +
+ --- -**Error querying blockdata** +
+ +## Specific Errors + +
+error querying block data +
The relayer looks back in time at historical transactions and needs to have an index of them. Specifically check `~/./config/config.toml` has the following fields set: @@ -62,10 +90,14 @@ Specifically check `~/./config/config.toml` has the following fie indexer = "kv" index_all_tags = true ``` ---- -**Error building or broadcasting transaction** +
+ +
+error building or broadcasting transaction + +
When preparing a transaction for relaying, the amount of gas that the transaction will consume is unknown. To compute how much gas the transaction will need, the transaction is prepared with 0 gas and delivered as a `/cosmos.tx.v1beta1.Service/Simulate` query to the RPC endpoint. Recently chains have been creating AnteHandlers in which 0 gas triggers an error case: ``` @@ -91,4 +123,28 @@ A workaround is available in which the `min-gas-amount` may be set in the chain' output-format: json sign-mode: direct ``` + +
+ + +
+invalid header: new header has a time from the future + +
+This is most likely an rpc issue. +The latest block time on the source and destination chain have likely drifted apart. + +You can confirm by this by checking the latest block time on each chain: + +```shell +grpcurl -plaintext cosmos.base.tendermint.v1beta1.Service.GetLatestBlock | grep '"time":' +``` + +The solution here is to either use a different RPC endpoint OR if you are in control of the RPC, try restarting the node. + +
+ +
+
+ [<-- Create Path Across Chains](create-path-across-chain.md) - [Features -->](./features.md) \ No newline at end of file diff --git a/examples/config_EXAMPLE.yaml b/examples/config_EXAMPLE.yaml index dd4ad343d..900d9d608 100644 --- a/examples/config_EXAMPLE.yaml +++ b/examples/config_EXAMPLE.yaml @@ -3,6 +3,7 @@ global: timeout: 10s memo: "" light-cache-size: 20 + log-level: "info" chains: cosmoshub: type: cosmos diff --git a/go.mod b/go.mod index da8ff06a6..f7bec65ce 100644 --- a/go.mod +++ b/go.mod @@ -3,192 +3,206 @@ module github.com/cosmos/relayer/v2 go 1.21 require ( - cosmossdk.io/api v0.3.1 - cosmossdk.io/errors v1.0.0 - cosmossdk.io/math v1.1.2 - github.com/avast/retry-go/v4 v4.3.2 - github.com/btcsuite/btcd v0.23.4 - github.com/btcsuite/btcd/btcutil v1.1.3 - github.com/cometbft/cometbft v0.37.2 - github.com/cosmos/cosmos-proto v1.0.0-beta.2 - github.com/cosmos/cosmos-sdk v0.47.5 + cosmossdk.io/api v0.7.3 + cosmossdk.io/errors v1.0.1 + cosmossdk.io/math v1.2.0 + cosmossdk.io/store v1.0.2 + cosmossdk.io/x/feegrant v0.1.0 + cosmossdk.io/x/tx v0.13.0 + cosmossdk.io/x/upgrade v0.1.0 + github.com/avast/retry-go/v4 v4.5.1 + github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd + github.com/btcsuite/btcd/btcutil v1.1.5 + github.com/cometbft/cometbft v0.38.5 + github.com/cosmos/cosmos-proto v1.0.0-beta.4 + github.com/cosmos/cosmos-sdk v0.50.4 github.com/cosmos/go-bip39 v1.0.0 - github.com/cosmos/gogoproto v1.4.10 - github.com/cosmos/ibc-go/modules/capability v1.0.0-rc1 - github.com/cosmos/ibc-go/v7 v7.3.0 + github.com/cosmos/gogoproto v1.4.11 + github.com/cosmos/ibc-go/modules/capability v1.0.0 + github.com/cosmos/ibc-go/v8 v8.0.0 github.com/cosmos/ics23/go v0.10.0 - github.com/ethereum/go-ethereum v1.10.26 + github.com/ethereum/go-ethereum v1.13.14 github.com/gofrs/flock v0.8.1 - github.com/google/go-cmp v0.5.9 github.com/google/go-github/v43 v43.0.0 github.com/grpc-ecosystem/grpc-gateway v1.16.0 github.com/jsternberg/zap-logfmt v1.3.0 - github.com/prometheus/client_golang v1.14.0 - github.com/spf13/cobra v1.7.0 - github.com/spf13/viper v1.16.0 + github.com/prometheus/client_golang v1.18.0 + github.com/spf13/cobra v1.8.0 + github.com/spf13/viper v1.18.2 + github.com/strangelove-ventures/cometbft-client v0.1.0 github.com/stretchr/testify v1.8.4 github.com/tyler-smith/go-bip39 v1.1.0 - go.uber.org/multierr v1.8.0 - go.uber.org/zap v1.24.0 - golang.org/x/mod v0.11.0 - golang.org/x/sync v0.2.0 - golang.org/x/text v0.12.0 - google.golang.org/grpc v1.56.2 + go.uber.org/multierr v1.10.0 + go.uber.org/zap v1.26.0 + golang.org/x/sync v0.5.0 + golang.org/x/text v0.14.0 + google.golang.org/grpc v1.60.1 gopkg.in/yaml.v2 v2.4.0 gopkg.in/yaml.v3 v3.0.1 ) require ( - cloud.google.com/go v0.110.4 // indirect - cloud.google.com/go/compute v1.20.1 // indirect + cloud.google.com/go v0.110.10 // indirect + cloud.google.com/go/compute v1.23.3 // indirect cloud.google.com/go/compute/metadata v0.2.3 // indirect - cloud.google.com/go/iam v1.1.0 // indirect - cloud.google.com/go/storage v1.30.1 // indirect - cosmossdk.io/core v0.5.1 // indirect + cloud.google.com/go/iam v1.1.5 // indirect + cloud.google.com/go/storage v1.35.1 // indirect + cosmossdk.io/collections v0.4.0 // indirect + cosmossdk.io/core v0.11.0 // indirect cosmossdk.io/depinject v1.0.0-alpha.4 // indirect - cosmossdk.io/log v1.2.1 // indirect - cosmossdk.io/tools/rosetta v0.2.1 // indirect + cosmossdk.io/log v1.3.1 // indirect filippo.io/edwards25519 v1.0.0 // indirect github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect github.com/99designs/keyring v1.2.1 // indirect - github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d // indirect - github.com/armon/go-metrics v0.4.1 // indirect - github.com/aws/aws-sdk-go v1.44.203 // indirect - github.com/benbjohnson/clock v1.3.0 // indirect + github.com/DataDog/datadog-go v3.2.0+incompatible // indirect + github.com/DataDog/zstd v1.5.5 // indirect + github.com/aws/aws-sdk-go v1.44.312 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d // indirect github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 // indirect + github.com/bits-and-blooms/bitset v1.10.0 // indirect github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect - github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 // indirect + github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 // indirect github.com/cenkalti/backoff/v4 v4.1.3 // indirect github.com/cespare/xxhash v1.1.0 // indirect github.com/cespare/xxhash/v2 v2.2.0 // indirect github.com/chzyer/readline v1.5.1 // indirect - github.com/cockroachdb/errors v1.10.0 // indirect + github.com/cockroachdb/errors v1.11.1 // indirect github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect + github.com/cockroachdb/pebble v1.1.0 // indirect github.com/cockroachdb/redact v1.1.5 // indirect - github.com/coinbase/rosetta-sdk-go/types v1.0.0 // indirect - github.com/cometbft/cometbft-db v0.8.0 // indirect - github.com/confio/ics23/go v0.9.0 // indirect + github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect + github.com/cometbft/cometbft-db v0.9.1 // indirect + github.com/consensys/bavard v0.1.13 // indirect + github.com/consensys/gnark-crypto v0.12.1 // indirect github.com/cosmos/btcutil v1.0.5 // indirect + github.com/cosmos/cosmos-db v1.0.0 // indirect github.com/cosmos/gogogateway v1.2.0 // indirect - github.com/cosmos/iavl v0.20.0 // indirect - github.com/cosmos/ledger-cosmos-go v0.12.2 // indirect - github.com/cosmos/rosetta-sdk-go v0.10.0 // indirect - github.com/creachadair/taskgroup v0.4.2 // indirect + github.com/cosmos/iavl v1.0.1 // indirect + github.com/cosmos/ledger-cosmos-go v0.13.3 // indirect + github.com/crate-crypto/go-kzg-4844 v0.7.0 // indirect github.com/danieljoos/wincred v1.1.2 // indirect - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f // indirect github.com/dgraph-io/badger/v2 v2.2007.4 // indirect github.com/dgraph-io/ristretto v0.1.1 // indirect github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 // indirect github.com/dustin/go-humanize v1.0.1 // indirect - github.com/dvsekhvalnov/jose2go v1.5.0 // indirect - github.com/felixge/httpsnoop v1.0.2 // indirect - github.com/fsnotify/fsnotify v1.6.0 // indirect - github.com/getsentry/sentry-go v0.23.0 // indirect + github.com/dvsekhvalnov/jose2go v1.6.0 // indirect + github.com/emicklei/dot v1.6.1 // indirect + github.com/ethereum/c-kzg-4844 v0.4.0 // indirect + github.com/fatih/color v1.15.0 // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/fsnotify/fsnotify v1.7.0 // indirect + github.com/getsentry/sentry-go v0.27.0 // indirect github.com/go-kit/kit v0.12.0 // indirect github.com/go-kit/log v0.2.1 // indirect github.com/go-logfmt/logfmt v0.6.0 // indirect - github.com/go-stack/stack v1.8.0 // indirect github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirect github.com/gogo/googleapis v1.4.1 // indirect github.com/gogo/protobuf v1.3.2 // indirect - github.com/golang/glog v1.1.0 // indirect + github.com/golang/glog v1.2.0 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/mock v1.6.0 // indirect github.com/golang/protobuf v1.5.3 // indirect - github.com/golang/snappy v0.0.4 // indirect + github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect github.com/google/btree v1.1.2 // indirect + github.com/google/go-cmp v0.6.0 // indirect github.com/google/go-querystring v1.1.0 // indirect github.com/google/orderedcode v0.0.1 // indirect - github.com/google/s2a-go v0.1.4 // indirect - github.com/google/uuid v1.3.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.2.3 // indirect - github.com/googleapis/gax-go/v2 v2.11.0 // indirect - github.com/gorilla/handlers v1.5.1 // indirect - github.com/gorilla/mux v1.8.0 // indirect - github.com/gorilla/websocket v1.5.0 // indirect - github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect + github.com/google/s2a-go v0.1.7 // indirect + github.com/google/uuid v1.4.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect + github.com/googleapis/gax-go/v2 v2.12.0 // indirect + github.com/gorilla/handlers v1.5.2 // indirect + github.com/gorilla/mux v1.8.1 // indirect + github.com/gorilla/websocket v1.5.1 // indirect + github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 // indirect github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c // indirect - github.com/gtank/merlin v0.1.1 // indirect - github.com/gtank/ristretto255 v0.1.2 // indirect github.com/hashicorp/go-cleanhttp v0.5.2 // indirect - github.com/hashicorp/go-getter v1.7.1 // indirect + github.com/hashicorp/go-getter v1.7.2 // indirect + github.com/hashicorp/go-hclog v1.5.0 // indirect github.com/hashicorp/go-immutable-radix v1.3.1 // indirect + github.com/hashicorp/go-metrics v0.5.1 // indirect + github.com/hashicorp/go-plugin v1.5.2 // indirect github.com/hashicorp/go-safetemp v1.0.0 // indirect github.com/hashicorp/go-version v1.6.0 // indirect - github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect + github.com/hashicorp/golang-lru v1.0.2 // indirect github.com/hashicorp/hcl v1.0.0 // indirect + github.com/hashicorp/yamux v0.1.1 // indirect github.com/hdevalence/ed25519consensus v0.1.0 // indirect - github.com/holiman/uint256 v1.2.0 // indirect + github.com/holiman/uint256 v1.2.4 // indirect github.com/huandu/skiplist v1.2.0 // indirect + github.com/iancoleman/strcase v0.3.0 // indirect github.com/improbable-eng/grpc-web v0.15.0 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/jmhodges/levigo v1.0.0 // indirect - github.com/klauspost/compress v1.16.3 // indirect + github.com/klauspost/compress v1.17.6 // indirect github.com/kr/pretty v0.3.1 // indirect github.com/kr/text v0.2.0 // indirect github.com/lib/pq v1.10.7 // indirect github.com/libp2p/go-buffer-pool v0.1.0 // indirect - github.com/linxGnu/grocksdb v1.7.16 // indirect + github.com/linxGnu/grocksdb v1.8.12 // indirect github.com/magiconair/properties v1.8.7 // indirect github.com/manifoldco/promptui v0.9.0 // indirect github.com/mattn/go-colorable v0.1.13 // indirect - github.com/mattn/go-isatty v0.0.19 // indirect - github.com/mattn/go-runewidth v0.0.13 // indirect - github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect - github.com/mimoo/StrobeGo v0.0.0-20210601165009-122bf33a46e0 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect github.com/minio/highwayhash v1.0.2 // indirect github.com/mitchellh/go-homedir v1.1.0 // indirect github.com/mitchellh/go-testing-interface v1.14.1 // indirect github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/mmcloughlin/addchain v0.4.0 // indirect github.com/mtibben/percent v0.2.1 // indirect - github.com/pelletier/go-toml/v2 v2.0.8 // indirect - github.com/petermattis/goid v0.0.0-20230317030725-371a4b8eda08 // indirect + github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a // indirect + github.com/oklog/run v1.1.0 // indirect + github.com/pelletier/go-toml/v2 v2.1.0 // indirect + github.com/petermattis/goid v0.0.0-20230904192822-1876fd5063bc // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/prometheus/client_model v0.3.0 // indirect - github.com/prometheus/common v0.42.0 // indirect - github.com/prometheus/procfs v0.9.0 // indirect - github.com/rakyll/statik v0.1.7 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/prometheus/client_model v0.6.0 // indirect + github.com/prometheus/common v0.47.0 // indirect + github.com/prometheus/procfs v0.12.0 // indirect github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect - github.com/rogpeppe/go-internal v1.11.0 // indirect + github.com/rogpeppe/go-internal v1.12.0 // indirect github.com/rs/cors v1.8.3 // indirect - github.com/rs/zerolog v1.30.0 // indirect + github.com/rs/zerolog v1.32.0 // indirect + github.com/sagikazarmark/locafero v0.4.0 // indirect + github.com/sagikazarmark/slog-shim v0.1.0 // indirect github.com/sasha-s/go-deadlock v0.3.1 // indirect - github.com/spf13/afero v1.9.5 // indirect - github.com/spf13/cast v1.5.1 // indirect - github.com/spf13/jwalterweatherman v1.1.0 // indirect + github.com/sourcegraph/conc v0.3.0 // indirect + github.com/spf13/afero v1.11.0 // indirect + github.com/spf13/cast v1.6.0 // indirect github.com/spf13/pflag v1.0.5 // indirect - github.com/subosito/gotenv v1.4.2 // indirect + github.com/subosito/gotenv v1.6.0 // indirect + github.com/supranational/blst v0.3.11 // indirect github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d // indirect github.com/tendermint/go-amino v0.16.0 // indirect - github.com/tidwall/btree v1.6.0 // indirect - github.com/tklauser/numcpus v0.4.0 // indirect + github.com/tidwall/btree v1.7.0 // indirect github.com/ulikunitz/xz v0.5.11 // indirect - github.com/zondax/hid v0.9.1 // indirect - github.com/zondax/ledger-go v0.14.1 // indirect - go.etcd.io/bbolt v1.3.7 // indirect + github.com/zondax/hid v0.9.2 // indirect + github.com/zondax/ledger-go v0.14.3 // indirect + go.etcd.io/bbolt v1.3.8 // indirect go.opencensus.io v0.24.0 // indirect - go.uber.org/atomic v1.10.0 // indirect - golang.org/x/crypto v0.11.0 // indirect - golang.org/x/exp v0.0.0-20230711153332-06a737ee72cb // indirect - golang.org/x/net v0.12.0 // indirect - golang.org/x/oauth2 v0.8.0 // indirect - golang.org/x/sys v0.11.0 // indirect - golang.org/x/term v0.10.0 // indirect + golang.org/x/crypto v0.19.0 // indirect + golang.org/x/exp v0.0.0-20240213143201-ec583247a57a // indirect + golang.org/x/net v0.20.0 // indirect + golang.org/x/oauth2 v0.16.0 // indirect + golang.org/x/sys v0.17.0 // indirect + golang.org/x/term v0.17.0 // indirect + golang.org/x/time v0.5.0 // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect - google.golang.org/api v0.126.0 // indirect - google.golang.org/appengine v1.6.7 // indirect - google.golang.org/genproto v0.0.0-20230706204954-ccb25ca9f130 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20230629202037-9506855d4529 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98 // indirect - google.golang.org/protobuf v1.31.0 // indirect + google.golang.org/api v0.153.0 // indirect + google.golang.org/appengine v1.6.8 // indirect + google.golang.org/genproto v0.0.0-20231211222908-989df2bf70f3 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20231120223509-83a465c0220f // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20231212172506-995d672761c0 // indirect + google.golang.org/protobuf v1.32.0 // indirect gopkg.in/ini.v1 v1.67.0 // indirect + gotest.tools/v3 v3.5.1 // indirect nhooyr.io/websocket v1.8.6 // indirect - pgregory.net/rapid v0.5.5 // indirect - sigs.k8s.io/yaml v1.3.0 // indirect + pgregory.net/rapid v1.1.0 // indirect + rsc.io/tmplfunc v0.0.3 // indirect + sigs.k8s.io/yaml v1.4.0 // indirect ) diff --git a/go.sum b/go.sum index 0eee861d6..6360b0305 100644 --- a/go.sum +++ b/go.sum @@ -3,7 +3,6 @@ cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= -cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= @@ -16,7 +15,6 @@ cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOY cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= -cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= @@ -32,8 +30,8 @@ cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w9 cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= -cloud.google.com/go v0.110.4 h1:1JYyxKMN9hd5dR2MYTPWkGUgcoxVVhg0LKNKEo0qvmk= -cloud.google.com/go v0.110.4/go.mod h1:+EYjdK8e5RME/VY/qLCAtuyALQ9q67dvuum8i+H5xsI= +cloud.google.com/go v0.110.10 h1:LXy9GEO+timppncPIAZoOj3l58LIU9k+kn48AN7IO3Y= +cloud.google.com/go v0.110.10/go.mod h1:v1OoFqYxiBkUrruItNM3eT4lLByNjxmJSV/xDKJNnic= cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= @@ -70,8 +68,8 @@ cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= -cloud.google.com/go/compute v1.20.1 h1:6aKEtlUiwEpJzM001l0yFkpXmUVXaN8W+fbkb2AZNbg= -cloud.google.com/go/compute v1.20.1/go.mod h1:4tCnrn48xsqlwSAiLf1HXMQk8CONslYbdiEZc9FEIbM= +cloud.google.com/go/compute v1.23.3 h1:6sVlXXBmbd7jNX0Ipq0trII3e4n1/MsADLK6a+aiVlk= +cloud.google.com/go/compute v1.23.3/go.mod h1:VCgBUoMnIVIR0CscqQiPJLAG25E3ZRZMzcFZeQ+h8CI= cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY= cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= @@ -111,8 +109,8 @@ cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y97 cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= -cloud.google.com/go/iam v1.1.0 h1:67gSqaPukx7O8WLLHMa0PNs3EBGd2eE4d+psbO/CO94= -cloud.google.com/go/iam v1.1.0/go.mod h1:nxdHjaKfCr7fNYx/HJMM8LgiMugmveWlkatear5gVyk= +cloud.google.com/go/iam v1.1.5 h1:1jTsCu4bcsNsE4iiqNT5SHwrDRCfRmIaaaVFhRveTJI= +cloud.google.com/go/iam v1.1.5/go.mod h1:rB6P/Ic3mykPbFio+vo7403drjlgvoWfYpJhMXEbzv8= cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= @@ -170,12 +168,11 @@ cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0Zeo cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= -cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= -cloud.google.com/go/storage v1.30.1 h1:uOdMxAs8HExqBlnLtnQyP0YkvbiDpdGShGKtx6U/oNM= -cloud.google.com/go/storage v1.30.1/go.mod h1:NfxhC0UJE1aXSx7CIIbCf7y9HKT7BiccwkR7+P7gN8E= +cloud.google.com/go/storage v1.35.1 h1:B59ahL//eDfx2IIKFBeT5Atm9wnNmj3+8xG/W4WB//w= +cloud.google.com/go/storage v1.35.1/go.mod h1:M6M/3V/D3KpzMTJyPOR/HU6n2Si5QdaXYEsng2xgOs8= cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= @@ -187,20 +184,34 @@ cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xX cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg= cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0= cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M= -cosmossdk.io/api v0.3.1 h1:NNiOclKRR0AOlO4KIqeaG6PS6kswOMhHD0ir0SscNXE= -cosmossdk.io/api v0.3.1/go.mod h1:DfHfMkiNA2Uhy8fj0JJlOCYOBp4eWUUJ1te5zBGNyIw= -cosmossdk.io/core v0.5.1 h1:vQVtFrIYOQJDV3f7rw4pjjVqc1id4+mE0L9hHP66pyI= -cosmossdk.io/core v0.5.1/go.mod h1:KZtwHCLjcFuo0nmDc24Xy6CRNEL9Vl/MeimQ2aC7NLE= +cosmossdk.io/api v0.7.3 h1:V815i8YOwOAQa1rLCsSMjVG5Gnzs02JLq+l7ks8s1jk= +cosmossdk.io/api v0.7.3/go.mod h1:IcxpYS5fMemZGqyYtErK7OqvdM0C8kdW3dq8Q/XIG38= +cosmossdk.io/client/v2 v2.0.0-beta.1 h1:XkHh1lhrLYIT9zKl7cIOXUXg2hdhtjTPBUfqERNA1/Q= +cosmossdk.io/client/v2 v2.0.0-beta.1/go.mod h1:JEUSu9moNZQ4kU3ir1DKD5eU4bllmAexrGWjmb9k8qU= +cosmossdk.io/collections v0.4.0 h1:PFmwj2W8szgpD5nOd8GWH6AbYNi1f2J6akWXJ7P5t9s= +cosmossdk.io/collections v0.4.0/go.mod h1:oa5lUING2dP+gdDquow+QjlF45eL1t4TJDypgGd+tv0= +cosmossdk.io/core v0.11.0 h1:vtIafqUi+1ZNAE/oxLOQQ7Oek2n4S48SWLG8h/+wdbo= +cosmossdk.io/core v0.11.0/go.mod h1:LaTtayWBSoacF5xNzoF8tmLhehqlA9z1SWiPuNC6X1w= cosmossdk.io/depinject v1.0.0-alpha.4 h1:PLNp8ZYAMPTUKyG9IK2hsbciDWqna2z1Wsl98okJopc= cosmossdk.io/depinject v1.0.0-alpha.4/go.mod h1:HeDk7IkR5ckZ3lMGs/o91AVUc7E596vMaOmslGFM3yU= -cosmossdk.io/errors v1.0.0 h1:nxF07lmlBbB8NKQhtJ+sJm6ef5uV1XkvPXG2bUntb04= -cosmossdk.io/errors v1.0.0/go.mod h1:+hJZLuhdDE0pYN8HkOrVNwrIOYvUGnn6+4fjnJs/oV0= -cosmossdk.io/log v1.2.1 h1:Xc1GgTCicniwmMiKwDxUjO4eLhPxoVdI9vtMW8Ti/uk= -cosmossdk.io/log v1.2.1/go.mod h1:GNSCc/6+DhFIj1aLn/j7Id7PaO8DzNylUZoOYBL9+I4= -cosmossdk.io/math v1.1.2 h1:ORZetZCTyWkI5GlZ6CZS28fMHi83ZYf+A2vVnHNzZBM= -cosmossdk.io/math v1.1.2/go.mod h1:l2Gnda87F0su8a/7FEKJfFdJrM0JZRXQaohlgJeyQh0= -cosmossdk.io/tools/rosetta v0.2.1 h1:ddOMatOH+pbxWbrGJKRAawdBkPYLfKXutK9IETnjYxw= -cosmossdk.io/tools/rosetta v0.2.1/go.mod h1:Pqdc1FdvkNV3LcNIkYWt2RQY6IP1ge6YWZk8MhhO9Hw= +cosmossdk.io/errors v1.0.1 h1:bzu+Kcr0kS/1DuPBtUFdWjzLqyUuCiyHjyJB6srBV/0= +cosmossdk.io/errors v1.0.1/go.mod h1:MeelVSZThMi4bEakzhhhE/CKqVv3nOJDA25bIqRDu/U= +cosmossdk.io/log v1.3.1 h1:UZx8nWIkfbbNEWusZqzAx3ZGvu54TZacWib3EzUYmGI= +cosmossdk.io/log v1.3.1/go.mod h1:2/dIomt8mKdk6vl3OWJcPk2be3pGOS8OQaLUM/3/tCM= +cosmossdk.io/math v1.2.0 h1:8gudhTkkD3NxOP2YyyJIYYmt6dQ55ZfJkDOaxXpy7Ig= +cosmossdk.io/math v1.2.0/go.mod h1:l2Gnda87F0su8a/7FEKJfFdJrM0JZRXQaohlgJeyQh0= +cosmossdk.io/store v1.0.2 h1:lSg5BTvJBHUDwswNNyeh4K/CbqiHER73VU4nDNb8uk0= +cosmossdk.io/store v1.0.2/go.mod h1:EFtENTqVTuWwitGW1VwaBct+yDagk7oG/axBMPH+FXs= +cosmossdk.io/x/circuit v0.1.0 h1:IAej8aRYeuOMritczqTlljbUVHq1E85CpBqaCTwYgXs= +cosmossdk.io/x/circuit v0.1.0/go.mod h1:YDzblVE8+E+urPYQq5kq5foRY/IzhXovSYXb4nwd39w= +cosmossdk.io/x/evidence v0.1.0 h1:J6OEyDl1rbykksdGynzPKG5R/zm6TacwW2fbLTW4nCk= +cosmossdk.io/x/evidence v0.1.0/go.mod h1:hTaiiXsoiJ3InMz1uptgF0BnGqROllAN8mwisOMMsfw= +cosmossdk.io/x/feegrant v0.1.0 h1:c7s3oAq/8/UO0EiN1H5BIjwVntujVTkYs35YPvvrdQk= +cosmossdk.io/x/feegrant v0.1.0/go.mod h1:4r+FsViJRpcZif/yhTn+E0E6OFfg4n0Lx+6cCtnZElU= +cosmossdk.io/x/tx v0.13.0 h1:8lzyOh3zONPpZv2uTcUmsv0WTXy6T1/aCVDCqShmpzU= +cosmossdk.io/x/tx v0.13.0/go.mod h1:CpNQtmoqbXa33/DVxWQNx5Dcnbkv2xGUhL7tYQ5wUsY= +cosmossdk.io/x/upgrade v0.1.0 h1:z1ZZG4UL9ICTNbJDYZ6jOnF9GdEK9wyoEFi4BUScHXE= +cosmossdk.io/x/upgrade v0.1.0/go.mod h1:/6jjNGbiPCNtmA1N+rBtP601sr0g4ZXuj3yC6ClPCGY= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= filippo.io/edwards25519 v1.0.0 h1:0wAIcmJUqRdI8IJ/3eGi5/HwXZWPujYXXlkrQogz0Ek= filippo.io/edwards25519 v1.0.0/go.mod h1:N1IkdkCkiLB6tki+MYJoSx2JTY9NUlxZE7eHn5EwJns= @@ -208,26 +219,27 @@ github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 h1:/vQbFIOMb github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4/go.mod h1:hN7oaIRCjzsZ2dE+yG5k+rsdt3qcwykqK6HVGcKwsw4= github.com/99designs/keyring v1.2.1 h1:tYLp1ULvO7i3fI5vE21ReQuj99QFSs7lGm0xWyJo87o= github.com/99designs/keyring v1.2.1/go.mod h1:fc+wB5KTk9wQ9sDx0kFXB3A0MaeGHM9AwRStKOQ5vOA= -github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8= -github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0= +github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= -github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d h1:nalkkPQcITbvhmL4+C4cKA87NW0tfm3Kl9VXRoPywFg= -github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d/go.mod h1:URdX5+vg25ts3aCh8H5IFZybJYKWhJHYMTnf+ULtoC4= +github.com/DataDog/datadog-go v3.2.0+incompatible h1:qSG2N4FghB1He/r2mFrWKCaL7dXCilEuNEeAn20fdD4= github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= +github.com/DataDog/zstd v1.5.5 h1:oWf5W7GtOLgp6bciQYDmhHHjdhYkALu6S/5Ni9ZgSvQ= +github.com/DataDog/zstd v1.5.5/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= -github.com/Microsoft/go-winio v0.6.0 h1:slsWYD/zyx7lCXoZVlvQrj0hPTM1HI4+v1sIda2yDvg= -github.com/Microsoft/go-winio v0.6.0/go.mod h1:cTAf44im0RAYeL23bpB+fzCyDH2MJiz2BO69KH/soAE= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw= github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= -github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 h1:fLjPD/aNc3UIOA6tDi6QXUemppXK3P9BI7mr2hd6gx8= -github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= -github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o= -github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw= +github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= +github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= +github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= +github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE= github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= github.com/adlio/schema v1.3.3 h1:oBJn8I02PyTB466pZO1UZEn1TV5XLlifBSyMrmHl/1I= @@ -245,20 +257,17 @@ github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= -github.com/armon/go-metrics v0.4.1 h1:hR91U9KYmb6bLBYLQjyM+3j+rcd/UhE+G78SFnF8gJA= -github.com/armon/go-metrics v0.4.1/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= -github.com/avast/retry-go/v4 v4.3.2 h1:x4sTEu3jSwr7zNjya8NTdIN+U88u/jtO/q3OupBoDtM= -github.com/avast/retry-go/v4 v4.3.2/go.mod h1:rg6XFaiuFYII0Xu3RDbZQkxCofFwruZKW8oEF1jpWiU= +github.com/avast/retry-go/v4 v4.5.1 h1:AxIx0HGi4VZ3I02jr78j5lZ3M6x1E0Ivxa6b0pUUh7o= +github.com/avast/retry-go/v4 v4.5.1/go.mod h1:/sipNsvNB3RRuT5iNcb6h73nw3IBmXJ/H3XrCQYSOpc= github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go v1.44.122/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo= -github.com/aws/aws-sdk-go v1.44.203 h1:pcsP805b9acL3wUqa4JR2vg1k2wnItkDYNvfmcy6F+U= -github.com/aws/aws-sdk-go v1.44.203/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= +github.com/aws/aws-sdk-go v1.44.312 h1:llrElfzeqG/YOLFFKjg1xNpZCFJ2xraIi3PqSuP+95k= +github.com/aws/aws-sdk-go v1.44.312/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g= -github.com/benbjohnson/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A= -github.com/benbjohnson/clock v1.3.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= @@ -268,22 +277,24 @@ github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 h1:41iFGWnSlI2gVpmOtVTJZNodLdLQLn/KsJqFvXwnd/s= github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= +github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M= -github.com/btcsuite/btcd v0.23.0/go.mod h1:0QJIIN1wwIXF/3G/m87gIwGniDMDQqjVn4SZgnFpsYY= -github.com/btcsuite/btcd v0.23.4 h1:IzV6qqkfwbItOS/sg/aDfPDsjPP8twrCOE2R93hxMlQ= -github.com/btcsuite/btcd v0.23.4/go.mod h1:0QJIIN1wwIXF/3G/m87gIwGniDMDQqjVn4SZgnFpsYY= +github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd h1:js1gPwhcFflTZ7Nzl7WHaOTlTr5hIrR4n1NM4v9n4Kw= +github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A= github.com/btcsuite/btcd/btcec/v2 v2.1.0/go.mod h1:2VzYrv4Gm4apmbVVsSq5bqf1Ec8v56E48Vt0Y/umPgA= github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE= github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U= github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= github.com/btcsuite/btcd/btcutil v1.0.0/go.mod h1:Uoxwv0pqYWhD//tfTiipkxNfdhG9UrLwaeswfjfdF0A= github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUBTwmWH/0Jn8VHE= -github.com/btcsuite/btcd/btcutil v1.1.3 h1:xfbtw8lwpp0G6NwSHb+UE67ryTFHJAiNuipusjXSohQ= -github.com/btcsuite/btcd/btcutil v1.1.3/go.mod h1:UR7dsSJzJUfMmFiiLlIrMq1lS9jh9EdCV7FStZSnpi0= +github.com/btcsuite/btcd/btcutil v1.1.5 h1:+wER79R5670vs/ZusMTF1yTcRYE5GUsFbdjdisflzM8= +github.com/btcsuite/btcd/btcutil v1.1.5/go.mod h1:PSZZ4UitpLBWzxGd5VGOrLnmOjtPP/a6HaFo12zMs00= github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 h1:59Kx4K6lzOW5w6nFlA0v5+lk/6sjybR934QNHSJZPTQ= +github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= @@ -293,8 +304,8 @@ github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= -github.com/bufbuild/protocompile v0.4.0 h1:LbFKd2XowZvQ/kajzguUp2DC9UEIQhIq77fZZlaQsNA= -github.com/bufbuild/protocompile v0.4.0/go.mod h1:3v93+mbWn/v3xzN+31nwkJfrEpAUwp+BagBSZWx+TP8= +github.com/bufbuild/protocompile v0.6.0 h1:Uu7WiSQ6Yj9DbkdnOe7U4mNKp58y9WDMKDn28/ZlunY= +github.com/bufbuild/protocompile v0.6.0/go.mod h1:YNP35qEYoYGme7QMtz5SBCoN4kL4g12jTtjuzRNdjpE= github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ= github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4= github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= @@ -333,21 +344,27 @@ github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWH github.com/cockroachdb/apd/v2 v2.0.2 h1:weh8u7Cneje73dDh+2tEVLUvyBc89iwepWCD8b8034E= github.com/cockroachdb/apd/v2 v2.0.2/go.mod h1:DDxRlzC2lo3/vSlmSoS7JkqbbrARPuFOGr0B9pvN3Gw= github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8= -github.com/cockroachdb/errors v1.10.0 h1:lfxS8zZz1+OjtV4MtNWgboi/W5tyLEB6VQZBXN+0VUU= -github.com/cockroachdb/errors v1.10.0/go.mod h1:lknhIsEVQ9Ss/qKDBQS/UqFSvPQjOwNq2qyKAxtHRqE= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= +github.com/cockroachdb/errors v1.11.1 h1:xSEW75zKaKCWzR3OfxXUxgrk/NtT4G1MiOv5lWZazG8= +github.com/cockroachdb/errors v1.11.1/go.mod h1:8MUxA3Gi6b25tYlFEBGLf+D8aISL+M4MIpiWMSNRfxw= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/pebble v1.1.0 h1:pcFh8CdCIt2kmEpK0OIatq67Ln9uGDYY3d5XnE0LJG4= +github.com/cockroachdb/pebble v1.1.0/go.mod h1:sEHm5NOXxyiAoKWhoFxT8xMgd/f3RA6qUqQ1BXKrh2E= github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI= -github.com/coinbase/rosetta-sdk-go/types v1.0.0 h1:jpVIwLcPoOeCR6o1tU+Xv7r5bMONNbHU7MuEHboiFuA= -github.com/coinbase/rosetta-sdk-go/types v1.0.0/go.mod h1:eq7W2TMRH22GTW0N0beDnN931DW0/WOI1R2sdHNHG4c= -github.com/cometbft/cometbft v0.37.2 h1:XB0yyHGT0lwmJlFmM4+rsRnczPlHoAKFX6K8Zgc2/Jc= -github.com/cometbft/cometbft v0.37.2/go.mod h1:Y2MMMN//O5K4YKd8ze4r9jmk4Y7h0ajqILXbH5JQFVs= -github.com/cometbft/cometbft-db v0.8.0 h1:vUMDaH3ApkX8m0KZvOFFy9b5DZHBAjsnEuo9AKVZpjo= -github.com/cometbft/cometbft-db v0.8.0/go.mod h1:6ASCP4pfhmrCBpfk01/9E1SI29nD3HfVHrY4PG8x5c0= -github.com/confio/ics23/go v0.9.0 h1:cWs+wdbS2KRPZezoaaj+qBleXgUk5WOQFMP3CQFGTr4= -github.com/confio/ics23/go v0.9.0/go.mod h1:4LPZ2NYqnYIVRklaozjNR1FScgDJ2s5Xrp+e/mYVRak= +github.com/cometbft/cometbft v0.38.5 h1:4lOcK5VTPrfbLOhNHmPYe6c7eDXHtBdMCQuKbAfFJdU= +github.com/cometbft/cometbft v0.38.5/go.mod h1:0tqKin+KQs8zDwzYD8rPHzSBIDNPuB4NrwwGDNb/hUg= +github.com/cometbft/cometbft-db v0.9.1 h1:MIhVX5ja5bXNHF8EYrThkG9F7r9kSfv8BX4LWaxWJ4M= +github.com/cometbft/cometbft-db v0.9.1/go.mod h1:iliyWaoV0mRwBJoizElCwwRA9Tf7jZJOURcRZF9m60U= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= github.com/containerd/continuity v0.3.0 h1:nisirsYROK15TAMVukJOUyGJjz4BNQJBVsNvAXZJ/eg= github.com/containerd/continuity v0.3.0/go.mod h1:wJEAIwKOm/pBZuBd0JmeTvnLquTB1Ag8espWhkykbPM= github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= @@ -358,48 +375,51 @@ github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSV github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/cosmos/btcutil v1.0.5 h1:t+ZFcX77LpKtDBhjucvnOH8C2l2ioGsBNEQ3jef8xFk= github.com/cosmos/btcutil v1.0.5/go.mod h1:IyB7iuqZMJlthe2tkIFL33xPyzbFYP0XVdS8P5lUPis= -github.com/cosmos/cosmos-proto v1.0.0-beta.2 h1:X3OKvWgK9Gsejo0F1qs5l8Qn6xJV/AzgIWR2wZ8Nua8= -github.com/cosmos/cosmos-proto v1.0.0-beta.2/go.mod h1:+XRCLJ14pr5HFEHIUcn51IKXD1Fy3rkEQqt4WqmN4V0= -github.com/cosmos/cosmos-sdk v0.47.5 h1:n1+WjP/VM/gAEOx3TqU2/Ny734rj/MX1kpUnn7zVJP8= -github.com/cosmos/cosmos-sdk v0.47.5/go.mod h1:EHwCeN9IXonsjKcjpS12MqeStdZvIdxt3VYXhus3G3c= -github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y= +github.com/cosmos/cosmos-db v1.0.0 h1:EVcQZ+qYag7W6uorBKFPvX6gRjw6Uq2hIh4hCWjuQ0E= +github.com/cosmos/cosmos-db v1.0.0/go.mod h1:iBvi1TtqaedwLdcrZVYRSSCb6eSy61NLj4UNmdIgs0U= +github.com/cosmos/cosmos-proto v1.0.0-beta.4 h1:aEL7tU/rLOmxZQ9z4i7mzxcLbSCY48OdY7lIWTLG7oU= +github.com/cosmos/cosmos-proto v1.0.0-beta.4/go.mod h1:oeB+FyVzG3XrQJbJng0EnV8Vljfk9XvTIpGILNU/9Co= +github.com/cosmos/cosmos-sdk v0.50.4 h1:hQT5/+Z1XXNF7skaPq0i247Ts2dzzqg/j2WO/BPHSto= +github.com/cosmos/cosmos-sdk v0.50.4/go.mod h1:UbShFs6P8Ly29xxJvkNGaNaL/UGj5a686NRtb1Cqra0= github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY= github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= github.com/cosmos/gogogateway v1.2.0 h1:Ae/OivNhp8DqBi/sh2A8a1D0y638GpL3tkmLQAiKxTE= github.com/cosmos/gogogateway v1.2.0/go.mod h1:iQpLkGWxYcnCdz5iAdLcRBSw3h7NXeOkZ4GUkT+tbFI= github.com/cosmos/gogoproto v1.4.2/go.mod h1:cLxOsn1ljAHSV527CHOtaIP91kK6cCrZETRBrkzItWU= -github.com/cosmos/gogoproto v1.4.10 h1:QH/yT8X+c0F4ZDacDv3z+xE3WU1P1Z3wQoLMBRJoKuI= -github.com/cosmos/gogoproto v1.4.10/go.mod h1:3aAZzeRWpAwr+SS/LLkICX2/kDFyaYVzckBDzygIxek= -github.com/cosmos/iavl v0.20.0 h1:fTVznVlepH0KK8NyKq8w+U7c2L6jofa27aFX6YGlm38= -github.com/cosmos/iavl v0.20.0/go.mod h1:WO7FyvaZJoH65+HFOsDir7xU9FWk2w9cHXNW1XHcl7A= -github.com/cosmos/ibc-go/modules/capability v1.0.0-rc1 h1:BvSKnPFKxL+TTSLxGKwJN4x0ndCZj0yfXhSvmsQztSA= -github.com/cosmos/ibc-go/modules/capability v1.0.0-rc1/go.mod h1:A+CxAQdn2j6ihDTbClpEEBdHthWgAUAcHbRAQPY8sl4= -github.com/cosmos/ibc-go/v7 v7.3.0 h1:QtGeVMi/3JeLWuvEuC60sBHpAF40Oenx/y+bP8+wRRw= -github.com/cosmos/ibc-go/v7 v7.3.0/go.mod h1:mUmaHFXpXrEdcxfdXyau+utZf14pGKVUiXwYftRZZfQ= +github.com/cosmos/gogoproto v1.4.11 h1:LZcMHrx4FjUgrqQSWeaGC1v/TeuVFqSLa43CC6aWR2g= +github.com/cosmos/gogoproto v1.4.11/go.mod h1:/g39Mh8m17X8Q/GDEs5zYTSNaNnInBSohtaxzQnYq1Y= +github.com/cosmos/iavl v1.0.1 h1:D+mYbcRO2wptYzOM1Hxl9cpmmHU1ZEt9T2Wv5nZTeUw= +github.com/cosmos/iavl v1.0.1/go.mod h1:8xIUkgVvwvVrBu81scdPty+/Dx9GqwHnAvXz4cwF7RY= +github.com/cosmos/ibc-go/modules/capability v1.0.0 h1:r/l++byFtn7jHYa09zlAdSeevo8ci1mVZNO9+V0xsLE= +github.com/cosmos/ibc-go/modules/capability v1.0.0/go.mod h1:D81ZxzjZAe0ZO5ambnvn1qedsFQ8lOwtqicG6liLBco= +github.com/cosmos/ibc-go/v8 v8.0.0 h1:QKipnr/NGwc+9L7NZipURvmSIu+nw9jOIWTJuDBqOhg= +github.com/cosmos/ibc-go/v8 v8.0.0/go.mod h1:C6IiJom0F3cIQCD5fKwVPDrDK9j/xTu563AWuOmXois= github.com/cosmos/ics23/go v0.10.0 h1:iXqLLgp2Lp+EdpIuwXTYIQU+AiHj9mOC2X9ab++bZDM= github.com/cosmos/ics23/go v0.10.0/go.mod h1:ZfJSmng/TBNTBkFemHHHj5YY7VAU/MBU980F4VU1NG0= -github.com/cosmos/ledger-cosmos-go v0.12.2 h1:/XYaBlE2BJxtvpkHiBm97gFGSGmYGKunKyF3nNqAXZA= -github.com/cosmos/ledger-cosmos-go v0.12.2/go.mod h1:ZcqYgnfNJ6lAXe4HPtWgarNEY+B74i+2/8MhZw4ziiI= -github.com/cosmos/rosetta-sdk-go v0.10.0 h1:E5RhTruuoA7KTIXUcMicL76cffyeoyvNybzUGSKFTcM= -github.com/cosmos/rosetta-sdk-go v0.10.0/go.mod h1:SImAZkb96YbwvoRkzSMQB6noNJXFgWl/ENIznEoYQI4= +github.com/cosmos/ledger-cosmos-go v0.13.3 h1:7ehuBGuyIytsXbd4MP43mLeoN2LTOEnk5nvue4rK+yM= +github.com/cosmos/ledger-cosmos-go v0.13.3/go.mod h1:HENcEP+VtahZFw38HZ3+LS3Iv5XV6svsnkk9vdJtLr8= github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= -github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/creachadair/taskgroup v0.4.2 h1:jsBLdAJE42asreGss2xZGZ8fJra7WtwnHWeJFxv2Li8= -github.com/creachadair/taskgroup v0.4.2/go.mod h1:qiXUOSrbwAY3u0JPGTzObbE3yf9hcXHDKBZ2ZjpCbgM= +github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= +github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/danieljoos/wincred v1.1.2 h1:QLdCxFs1/Yl4zduvBdcHB8goaYk9RARS2SgLLRuAyr0= github.com/danieljoos/wincred v1.1.2/go.mod h1:GijpziifJoIBfYh+S7BbkdUTU4LfM+QnGqR5Vl2tAx0= github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= +github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y= +github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 h1:HbphB4TFFXpv7MNrT52FGrrgVXF1owhMVTHFZIlnvd4= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0/go.mod h1:DZGJHZMqrU4JJqFAWUS2UO1+lbSKsdiOoYi9Zzey7Fc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218= github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f h1:U5y3Y5UE0w7amNe7Z5G/twsBW0KEalRQXZzf8ufSh9I= github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f/go.mod h1:xH/i4TFMt8koVQZ6WFms69WAsDWr2XsYL3Hkl7jkoLE= @@ -420,12 +440,14 @@ github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:Htrtb github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/dvsekhvalnov/jose2go v1.5.0 h1:3j8ya4Z4kMCwT5nXIKFSV84YS+HdqSSO0VsTQxaLAeM= -github.com/dvsekhvalnov/jose2go v1.5.0/go.mod h1:QsHjhyTlD/lAVqn/NSbVZmSCGeDehTB/mPZadG+mhXU= +github.com/dvsekhvalnov/jose2go v1.6.0 h1:Y9gnSnP4qEI0+/uQkHvFXeD2PLPJeXEL+ySMEA2EjTY= +github.com/dvsekhvalnov/jose2go v1.6.0/go.mod h1:QsHjhyTlD/lAVqn/NSbVZmSCGeDehTB/mPZadG+mhXU= github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs= github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= +github.com/emicklei/dot v1.6.1 h1:ujpDlBkkwgWUY+qPId5IwapRW/xEoligRSYjioR6DFI= +github.com/emicklei/dot v1.6.1/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= @@ -437,25 +459,31 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.m github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/ethereum/go-ethereum v1.10.26 h1:i/7d9RBBwiXCEuyduBQzJw/mKmnvzsN14jqBmytw72s= -github.com/ethereum/go-ethereum v1.10.26/go.mod h1:EYFyF19u3ezGLD4RqOkLq+ZCXzYbLoNDdZlMt7kyKFg= +github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= +github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.13.14 h1:EwiY3FZP94derMCIam1iW4HFVrSgIcpsu0HwTQtm6CQ= +github.com/ethereum/go-ethereum v1.13.14/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/felixge/httpsnoop v1.0.2 h1:+nS9g82KMXccJ/wp0zyRW9ZBHFETmMGtkk+2CTTrW4o= -github.com/felixge/httpsnoop v1.0.2/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= +github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4= github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= -github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= -github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU= -github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= -github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= -github.com/getsentry/sentry-go v0.23.0 h1:dn+QRCeJv4pPt9OjVXiMcGIBIefaTJPw/h0bZWO05nE= -github.com/getsentry/sentry-go v0.23.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= +github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= +github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= +github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= @@ -472,6 +500,7 @@ github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2 github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o= github.com/go-kit/kit v0.12.0 h1:e4o3o3IsBfAKQh5Qbbiqyfu97Ku7jrO/JbohvztANh4= github.com/go-kit/kit v0.12.0/go.mod h1:lHd+EkCZPIwYItmGDDRdhinkzX2A1sj+M9biaEaizzs= +github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU= github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= @@ -479,8 +508,8 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4= github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= -github.com/go-ole/go-ole v1.2.1 h1:2lOsA72HgjxAuMlKpFiCbHTvu44PIVkZ5hqm3RSdI/E= -github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= github.com/go-playground/locales v0.14.0 h1:u50s323jtVGugKlcYeyzC0etD1HifMjqmJqb8WugfUU= @@ -492,7 +521,6 @@ github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GO github.com/go-playground/validator/v10 v10.11.1 h1:prmOlTVv+YjZjmRmNSF3VmspqJIxJWXmqUsHwfTRRkQ= github.com/go-playground/validator/v10 v10.11.1/go.mod h1:i+3WkQ1FvaUjjxh1kSvIA4dMGDBiPU55YFDl0WbKdWU= github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= -github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0= @@ -501,8 +529,8 @@ github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8= github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw= github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo= github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM= -github.com/goccy/go-json v0.9.11 h1:/pAaQDLHEoCq/5FFmSKBswWmK6H0e8g4159Kc/X/nqk= -github.com/goccy/go-json v0.9.11/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= +github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+Hoeu/iUR3ruzNvZ+yQfO03a0= github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= @@ -519,8 +547,8 @@ github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXP github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/glog v1.1.0 h1:/d3pCKDPWNnvIWe0vVUpNP32qc8U3PDVxySP/y360qE= -github.com/golang/glog v1.1.0/go.mod h1:pfYeQZ3JWZoXTV5sFc986z3HTpwQs9At6P4ImfuP3NQ= +github.com/golang/glog v1.2.0 h1:uCdmnmatrKCgMBlM4rMuJZWOkPDqdbZPnrMXDY4gI68= +github.com/golang/glog v1.2.0/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -559,8 +587,9 @@ github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.1.2 h1:xf4v41cLI2Z6FxbKm+8Bu+m8ifhj15JuZ9sa0jZCMUU= @@ -579,8 +608,9 @@ github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-github/v43 v43.0.0 h1:y+GL7LIsAIF2NZlJ46ZoC/D1W1ivZasT0lnWHMYPZ+U= github.com/google/go-github/v43 v43.0.0/go.mod h1:ZkTvvmCXBvsfPpTHXnH/d2hP9Y0cTbvN9kr5xqyXOIc= github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= @@ -607,7 +637,6 @@ github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hf github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= @@ -615,17 +644,19 @@ github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLe github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/google/s2a-go v0.1.4 h1:1kZ/sQM3srePvKs3tXAvQzo66XfcReoqFpIpIccE7Oc= -github.com/google/s2a-go v0.1.4/go.mod h1:Ej+mSEMGRnqRzjc7VtF+jdBwYG5fuJfiZ8ELkjEwM0A= +github.com/google/s2a-go v0.1.7 h1:60BLSyTrOV4/haCDW4zb1guZItoSq8foHCXrAnjBo/o= +github.com/google/s2a-go v0.1.7/go.mod h1:50CgR4k1jNlWBu4UfS4AcfhVe1r6pdZPygJ3R8F0Qdw= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= +github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg= -github.com/googleapis/enterprise-certificate-proxy v0.2.3 h1:yk9/cqRKtT9wXZSsRH9aurXEpJX+U6FLtpYTdC3R06k= -github.com/googleapis/enterprise-certificate-proxy v0.2.3/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs= +github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= @@ -635,37 +666,32 @@ github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99 github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= -github.com/googleapis/gax-go/v2 v2.11.0 h1:9V9PWXEsWnPpQhu/PeQIkS4eGzMlTLGgt80cUUI8Ki4= -github.com/googleapis/gax-go/v2 v2.11.0/go.mod h1:DxmR61SGKkGLa2xigwuZIQpkCI2S5iydzRfb3peWZJI= +github.com/googleapis/gax-go/v2 v2.12.0 h1:A+gCJKdRfqXkr+BIRGtZLibNXf0m1f9E4HG56etFpas= +github.com/googleapis/gax-go/v2 v2.12.0/go.mod h1:y+aIqrI5eb1YGMVJfuV3185Ts/D7qKpsEkdD5+I6QGU= github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= -github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg= -github.com/gorilla/handlers v1.5.1 h1:9lRY6j8DEeeBT10CvO9hGW0gmky0BprnvDI5vfhUHH4= -github.com/gorilla/handlers v1.5.1/go.mod h1:t8XrUpc4KVXb7HGyJ4/cEnwQiaxrX/hz1Zv/4g96P1Q= +github.com/gorilla/handlers v1.5.2 h1:cLTUSsNkgcwhgRqvCNmdbRWG0A3N4F+M2nWKdScwyEE= +github.com/gorilla/handlers v1.5.2/go.mod h1:dX+xVpaxdSw+q0Qek8SSsl3dfMk3jNddUkMzo0GtH0w= github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= -github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI= -github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= +github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= +github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY= +github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= github.com/grpc-ecosystem/go-grpc-middleware v1.2.2/go.mod h1:EaizFBKfUKtMIF5iaDEhniwNedqGo9FuLFzppDr3uwI= -github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw= -github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= +github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI= +github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8= github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c h1:6rhixN/i8ZofjG1Y75iExal34USq5p+wiN1tpie8IrU= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NMPJylDgVpX0MLRlPy15sqSwOFv/U1GZ2m21JhFfek0= -github.com/gtank/merlin v0.1.1-0.20191105220539-8318aed1a79f/go.mod h1:T86dnYJhcGOh5BjZFCJWTDeTK7XW8uE+E21Cy/bIQ+s= -github.com/gtank/merlin v0.1.1 h1:eQ90iG7K9pOhtereWsmyRJ6RAwcP4tHTDBHXNg+u5is= -github.com/gtank/merlin v0.1.1/go.mod h1:T86dnYJhcGOh5BjZFCJWTDeTK7XW8uE+E21Cy/bIQ+s= -github.com/gtank/ristretto255 v0.1.2 h1:JEqUCPA1NvLq5DwYtuzigd7ss8fwbYay9fi4/5uMzcc= -github.com/gtank/ristretto255 v0.1.2/go.mod h1:Ph5OpO6c7xKUGROZfWVLiJf9icMDwUeIvY4OmlYW69o= github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE= github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= @@ -673,13 +699,19 @@ github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtng github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= -github.com/hashicorp/go-getter v1.7.1 h1:SWiSWN/42qdpR0MdhaOc/bLR48PLuP1ZQtYLRlM69uY= -github.com/hashicorp/go-getter v1.7.1/go.mod h1:W7TalhMmbPmsSMdNjD0ZskARur/9GJ17cfHTRtXV744= +github.com/hashicorp/go-getter v1.7.2 h1:uJDtyXwEfalmp1PqdxuhZqrNkUyClZAhVeZYTArbqkg= +github.com/hashicorp/go-getter v1.7.2/go.mod h1:W7TalhMmbPmsSMdNjD0ZskARur/9GJ17cfHTRtXV744= +github.com/hashicorp/go-hclog v1.5.0 h1:bI2ocEMgcVlz55Oj1xZNBsVi900c7II+fWDyV9o+13c= +github.com/hashicorp/go-hclog v1.5.0/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M= github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc= github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= +github.com/hashicorp/go-metrics v0.5.1 h1:rfPwUqFU6uZXNvGl4hzjY8LEBsqFVU4si1H9/Hqck/U= +github.com/hashicorp/go-metrics v0.5.1/go.mod h1:KEjodfebIOuBYSAe/bHTm+HChmKSxAOXPBieMLYozDE= github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-plugin v1.5.2 h1:aWv8eimFqWlsEiMrYZdPYl+FdHaBJSN4AWwGWfT1G2Y= +github.com/hashicorp/go-plugin v1.5.2/go.mod h1:w1sAEES3g3PuV/RzUrgow20W2uErMly84hhD3um1WL4= github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs= github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo= @@ -687,34 +719,39 @@ github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoD github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= -github.com/hashicorp/go-uuid v1.0.1 h1:fv1ep09latC32wFoVwnqcnKJGnMSdBanPczbHAYm1BE= github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-uuid v1.0.2 h1:cfejS+Tpcp13yd5nYHWDI6qVCny6wyX2Mt5SGur2IGE= +github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/go-version v1.6.0 h1:feTTfFNnjP967rlCxM/I9g701jU+RN74YKx2mOkIeek= github.com/hashicorp/go-version v1.6.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs= -github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c= +github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= +github.com/hashicorp/yamux v0.1.1 h1:yrQxtgseBDrq9Y652vSRDvsKCJKOUD+GzTS4Y0Y8pvE= +github.com/hashicorp/yamux v0.1.1/go.mod h1:CtWFDAQgb7dxtzFs4tWbplKIe2jSi3+5vKbgIO0SLnQ= github.com/hdevalence/ed25519consensus v0.1.0 h1:jtBwzzcHuTmFrQN6xQZn6CQEO/V9f7HsjsjeEZ6auqU= github.com/hdevalence/ed25519consensus v0.1.0/go.mod h1:w3BHWjwJbFU29IRHL1Iqkw3sus+7FctEyM4RqDxYNzo= github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= -github.com/holiman/uint256 v1.2.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM= -github.com/holiman/uint256 v1.2.0/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw= +github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= +github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/huandu/go-assert v1.1.5 h1:fjemmA7sSfYHJD7CUqs9qTwwfdNAx7/j2/ZlHXzNB3c= github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U= github.com/huandu/skiplist v1.2.0 h1:gox56QD77HzSC0w+Ws3MH3iie755GBJU1OER3h5VsYw= github.com/huandu/skiplist v1.2.0/go.mod h1:7v3iFjLcSAzO4fN5B8dvebvo/qsfumiLiDXMrPiHF9w= github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg= +github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI= +github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/improbable-eng/grpc-web v0.15.0 h1:BN+7z6uNXZ1tQGcNAuaU1YjsLTApzkjt2tzCixLaUPQ= @@ -725,8 +762,8 @@ github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLf github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= -github.com/jhump/protoreflect v1.15.1 h1:HUMERORf3I3ZdX05WaQ6MIpd/NJ434hTp5YiKgfCL6c= -github.com/jhump/protoreflect v1.15.1/go.mod h1:jD/2GMKKE6OqX8qTjhADU1e6DShO+gavG9e0Q693nKo= +github.com/jhump/protoreflect v1.15.3 h1:6SFRuqU45u9hIZPJAoZ8c28T3nK64BNdp9w6jFonzls= +github.com/jhump/protoreflect v1.15.3/go.mod h1:4ORHmSBmlCW8fh3xHmJMGyul1zNqZK4Elxc8qKP+p1k= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= @@ -760,11 +797,10 @@ github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYs github.com/klauspost/compress v1.11.7/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs= github.com/klauspost/compress v1.12.3/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg= github.com/klauspost/compress v1.15.11/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM= -github.com/klauspost/compress v1.16.3 h1:XuJt9zzcnaz6a16/OU53ZjWp/v7/42WcR5t2a0PcNQY= -github.com/klauspost/compress v1.16.3/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI= +github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= @@ -773,6 +809,10 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= +github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w= github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY= @@ -782,8 +822,8 @@ github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6 github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg= github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM= github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4= -github.com/linxGnu/grocksdb v1.7.16 h1:Q2co1xrpdkr5Hx3Fp+f+f7fRGhQFQhvi/+226dtLmA8= -github.com/linxGnu/grocksdb v1.7.16/go.mod h1:JkS7pl5qWpGpuVb3bPqTz8nC12X3YtPZT+Xq7+QfQo4= +github.com/linxGnu/grocksdb v1.8.12 h1:1/pCztQUOa3BX/1gR3jSZDoaKFpeHFvQ1XrqZpSvZVo= +github.com/linxGnu/grocksdb v1.8.12/go.mod h1:xZCIb5Muw+nhbDK4Y5UJuOrin5MceOuiXkVUR7vp4WY= github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= @@ -791,6 +831,7 @@ github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3v github.com/manifoldco/promptui v0.9.0 h1:3V4HzJk1TtXW1MTZMP7mdlwbBpIinw3HztaIlYthEiA= github.com/manifoldco/promptui v0.9.0/go.mod h1:ka04sppxSGFAtxX0qhlYQjISsg9mR4GWtQEhdbn6Pgg= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= @@ -799,19 +840,15 @@ github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNx github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= -github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= -github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= -github.com/mimoo/StrobeGo v0.0.0-20181016162300-f8f6d4d2b643/go.mod h1:43+3pMjjKimDBf5Kr4ZFNGbLql1zKkbImw+fZbw3geM= -github.com/mimoo/StrobeGo v0.0.0-20210601165009-122bf33a46e0 h1:QRUSJEgZn2Snx0EmT/QLXibWjSUDjKWvXIT19NBVp94= -github.com/mimoo/StrobeGo v0.0.0-20210601165009-122bf33a46e0/go.mod h1:43+3pMjjKimDBf5Kr4ZFNGbLql1zKkbImw+fZbw3geM= github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g= github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY= github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= @@ -827,6 +864,9 @@ github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:F github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= +github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= +github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= @@ -851,8 +891,12 @@ github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLA github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= +github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a h1:dlRvE5fWabOchtH7znfiFCcOvmIYgOeAS5ifBXBlh9Q= +github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s= github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs= github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA= +github.com/oklog/run v1.1.0 h1:GEenZ1cK0+q0+wsJew9qUg/DyD8k3JzYsZAi5gYi2mA= +github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DVU= github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= @@ -870,8 +914,8 @@ github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7J github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro= -github.com/onsi/gomega v1.20.0 h1:8W0cWlwFkflGPLltQvLRB7ZVD5HuP6ng320w2IS245Q= -github.com/onsi/gomega v1.20.0/go.mod h1:DtrZpjmvpn2mPm4YWQa0/ALMDj9v4YxLgojwPeREyVo= +github.com/onsi/gomega v1.26.0 h1:03cDLK28U6hWvCAns6NeydX3zIm4SF3ci69ulidS32Q= +github.com/onsi/gomega v1.26.0/go.mod h1:r+zV744Re+DiYCIPRlYOTxn0YkOLcAnW8k1xXdMPGhM= github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk= github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= @@ -895,12 +939,12 @@ github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0Mw github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= -github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ= -github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4= +github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4= +github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc= github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac= github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5/go.mod h1:jvVRKCrJTQWu0XVbaOlby/2lO20uSCHEMzzplHXte1o= -github.com/petermattis/goid v0.0.0-20230317030725-371a4b8eda08 h1:hDSdbBuw3Lefr6R18ax0tZ2BJeNB3NehB3trOwYBsdU= -github.com/petermattis/goid v0.0.0-20230317030725-371a4b8eda08/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4= +github.com/petermattis/goid v0.0.0-20230904192822-1876fd5063bc h1:8bQZVK1X6BJR/6nYUPxQEP+ReTsceJTKizeuwjWOPUA= +github.com/petermattis/goid v0.0.0-20230904192822-1876fd5063bc/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4= github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc= github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= @@ -911,9 +955,9 @@ github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA= -github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs= @@ -921,36 +965,32 @@ github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5Fsn github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og= github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU= github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M= -github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw= -github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y= +github.com/prometheus/client_golang v1.18.0 h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk= +github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4= -github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= +github.com/prometheus/client_model v0.6.0 h1:k1v3CzpSRUTrKMppY35TLwPvxHqBu0bYgxZzqGIgaos= +github.com/prometheus/client_model v0.6.0/go.mod h1:NTQHnmxFpouOD0DpvP4XujX3CdOAGQPoaGhyTchlyt8= github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA= github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4= github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s= -github.com/prometheus/common v0.42.0 h1:EKsfXEYo4JpWMHH5cg+KOUWeuJSov1Id8zGR8eeI1YM= -github.com/prometheus/common v0.42.0/go.mod h1:xBwqVerjNdUDjgODMpudtOMwlOwf2SaTr1yjz4b7Zbc= +github.com/prometheus/common v0.47.0 h1:p5Cz0FNHo7SnWOmWmoRozVcjEp0bIVU8cV7OShpjL1k= +github.com/prometheus/common v0.47.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= github.com/prometheus/procfs v0.3.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= -github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI= -github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY= -github.com/prometheus/tsdb v0.7.1 h1:YZcsG11NqnK4czYLrWd9mpEuAJIHVQLwdrleYfszMAA= -github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= -github.com/rakyll/statik v0.1.7 h1:OF3QCZUuyPxuGEP7B4ypUa7sB/iHtqOTDYZXGM8KOdQ= -github.com/rakyll/statik v0.1.7/go.mod h1:AlZONWzMtEnMs7W4e/1LURLiI49pIMmp6V9Unghqrcc= +github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= +github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= @@ -960,18 +1000,22 @@ github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6So github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= -github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= github.com/rs/cors v1.8.3 h1:O+qNyWn7Z+F9M0ILBHgMVPuB1xTOucVd5gtaYyXBpRo= github.com/rs/cors v1.8.3/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= -github.com/rs/zerolog v1.30.0 h1:SymVODrcRsaRaSInD9yQtKbtWqwsfoPcRff/oRXLj4c= -github.com/rs/zerolog v1.30.0/go.mod h1:/tk+P47gFdPXq4QYjvCmT5/Gsug2nagsFWBWhAiSi1w= +github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0= +github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= +github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E= github.com/sasha-s/go-deadlock v0.3.1 h1:sqv7fDNShgjcaxkO0JNcOAlr8B9+cV5Ey/OB71efZx0= github.com/sasha-s/go-deadlock v0.3.1/go.mod h1:F73l+cr82YSh10GxyRI6qZiCgK64VaZjwesgfQ1/iLM= @@ -989,29 +1033,31 @@ github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM= github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= +github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= +github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= -github.com/spf13/afero v1.9.5 h1:stMpOSZFs//0Lv29HduCmli3GUfpFoF3Y1Q/aXj/wVM= -github.com/spf13/afero v1.9.5/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= -github.com/spf13/cast v1.5.1 h1:R+kOtfhWQE6TVQzY+4D7wJLBgkdVasCEFxSUBYBYIlA= -github.com/spf13/cast v1.5.1/go.mod h1:b9PdjNptOpzXr7Rq1q9gJML/2cdGQAo69NKzQ10KN48= +github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0= +github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= -github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I= -github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0= +github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0= +github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho= github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= -github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= -github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= -github.com/spf13/viper v1.16.0 h1:rGGH0XDZhdUOryiDWjmIvUSWpbNqisK8Wk0Vyefw8hc= -github.com/spf13/viper v1.16.0/go.mod h1:yg78JgCJcbrQOvV9YLXgkLaZqUidkY9K+Dd1FofRzQg= +github.com/spf13/viper v1.18.2 h1:LUXCnvUvSM6FXAsj6nnfc8Q2tp1dIgUfY9Kc8GsSOiQ= +github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk= +github.com/strangelove-ventures/cometbft-client v0.1.0 h1:fcA652QaaR0LDnyJOZVjZKtuyAawnVXaq/p1MWJSYD4= +github.com/strangelove-ventures/cometbft-client v0.1.0/go.mod h1:QzThgjzvsGgUNVNpGPitmxOWMIhp6a0oqf80nCRNt/0= github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= @@ -1030,22 +1076,23 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/subosito/gotenv v1.4.2 h1:X1TuBLAMDFbaTAChgCBLu3DU3UPyELpnF2jjJ2cz/S8= -github.com/subosito/gotenv v1.4.2/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= +github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d h1:vfofYNRScrDdvS342BElfbETmL1Aiz3i2t0zfRj16Hs= github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d/go.mod h1:RRCYJbIwD5jmqPI9XoAFR0OcDxqUctll6zUj/+B4S48= github.com/tendermint/go-amino v0.16.0 h1:GyhmgQKvqF82e2oZeuMSp9JTN0N09emoSZlb2lyGa2E= github.com/tendermint/go-amino v0.16.0/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME= -github.com/tidwall/btree v1.6.0 h1:LDZfKfQIBHGHWSwckhXI0RPSXzlo+KYdjK7FWSqOzzg= -github.com/tidwall/btree v1.6.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EUQ2cKY= -github.com/tklauser/go-sysconf v0.3.5 h1:uu3Xl4nkLzQfXNsWn15rPc/HQCJKObbt1dKJeWp3vU4= -github.com/tklauser/go-sysconf v0.3.5/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI= -github.com/tklauser/numcpus v0.4.0 h1:E53Dm1HjH1/R2/aoCtXtPgzmElmn51aOkhCFSuZq//o= -github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ= +github.com/tidwall/btree v1.7.0 h1:L1fkJH/AuEh5zBnnBbmTwQ5Lt+bRJ5A8EWecslvo9iI= +github.com/tidwall/btree v1.7.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EUQ2cKY= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= @@ -1054,8 +1101,8 @@ github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo= github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= -github.com/ugorji/go/codec v1.2.7 h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0= -github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY= +github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= +github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= github.com/ulikunitz/xz v0.5.11 h1:kpFauv27b6ynzBNT/Xy+1k+fK4WswhN/6PN5WhFAGw8= github.com/ulikunitz/xz v0.5.11/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= @@ -1069,13 +1116,13 @@ github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -github.com/zondax/hid v0.9.1 h1:gQe66rtmyZ8VeGFcOpbuH3r7erYtNEAezCAYu8LdkJo= -github.com/zondax/hid v0.9.1/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= -github.com/zondax/ledger-go v0.14.1 h1:Pip65OOl4iJ84WTpA4BKChvOufMhhbxED3BaihoZN4c= -github.com/zondax/ledger-go v0.14.1/go.mod h1:fZ3Dqg6qcdXWSOJFKMG8GCTnD7slO/RL2feOQv8K320= +github.com/zondax/hid v0.9.2 h1:WCJFnEDMiqGF64nlZz28E9qLVZ0KSJ7xpc5DLEyma2U= +github.com/zondax/hid v0.9.2/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= +github.com/zondax/ledger-go v0.14.3 h1:wEpJt2CEcBJ428md/5MgSLsXLBos98sBOyxNmCjfUCw= +github.com/zondax/ledger-go v0.14.3/go.mod h1:IKKaoxupuB43g4NxeQmbLXv7T9AlQyie1UpHb342ycI= go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= -go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ= -go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw= +go.etcd.io/bbolt v1.3.8 h1:xs88BrvEv273UsB79e0hcVrlUWmS0a8upikMFhSyAtA= +go.etcd.io/bbolt v1.3.8/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw= go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= @@ -1093,19 +1140,20 @@ go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ= -go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= -go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI= -go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk= +go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= -go.uber.org/multierr v1.8.0 h1:dg6GjLku4EH+249NNmoIciG9N/jURbDG+pFlTkhzIC8= -go.uber.org/multierr v1.8.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= +go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ= +go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= -go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60= -go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg= +go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= +go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= +go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= @@ -1115,15 +1163,11 @@ golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8U golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA= -golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio= +golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -1135,8 +1179,8 @@ golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= -golang.org/x/exp v0.0.0-20230711153332-06a737ee72cb h1:xIApU0ow1zwMa2uL1VDNeQlNVFTWMQxZUZCMDy0Q4Us= -golang.org/x/exp v0.0.0-20230711153332-06a737ee72cb/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= +golang.org/x/exp v0.0.0-20240213143201-ec583247a57a h1:HinSgX1tJRX3KsL//Gxynpw5CTOAIPhgL4W8PNiIpVE= +golang.org/x/exp v0.0.0-20240213143201-ec583247a57a/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= @@ -1163,8 +1207,8 @@ golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU= -golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.15.0 h1:SernR4v+D55NyBH2QiEQrlBAnj1ECL6AGrA5+dPaMY8= +golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -1207,7 +1251,6 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= @@ -1215,7 +1258,6 @@ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96b golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= @@ -1228,8 +1270,8 @@ golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= -golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50= -golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA= +golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo= +golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -1255,8 +1297,8 @@ golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= golang.org/x/oauth2 v0.1.0/go.mod h1:G9FE4dLTsbXUu90h/Pf85g4w1D+SSAgR+q46nJZ8M4A= -golang.org/x/oauth2 v0.8.0 h1:6dkIjl3j3LtZ/O3sTgZTMsLKSftL/B8Zgq4huOIIUu8= -golang.org/x/oauth2 v0.8.0/go.mod h1:yr7u4HXZRm1R1kBWqr/xKNqewf0plRYoB7sla+BCIXE= +golang.org/x/oauth2 v0.16.0 h1:aDkGMBSYxElaoP81NpoUoz2oo2R2wHdZpGToUxfyQrQ= +golang.org/x/oauth2 v0.16.0/go.mod h1:hqZ+0LWXsiVoZpeld6jVt06P3adbS2Uu911W1SsJv2o= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -1271,8 +1313,8 @@ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI= -golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= +golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1330,13 +1372,11 @@ golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -1349,6 +1389,7 @@ golang.org/x/sys v0.0.0-20210819135213-f52c844e1c1c/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -1368,17 +1409,17 @@ golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM= -golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.10.0 h1:3R7pNqamzBraeqj/Tj8qt1aQ2HpmlC+Cx/qL/7hn4/c= -golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o= +golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U= +golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1390,12 +1431,14 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc= -golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -1417,6 +1460,7 @@ golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -1451,7 +1495,6 @@ golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= @@ -1459,8 +1502,8 @@ golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM= -golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.18.0 h1:k8NLag8AGHnn+PHbl7g43CtqZAwG60vZkLqgyZgIHgQ= +golang.org/x/tools v0.18.0/go.mod h1:GL7B4CwcLLeo59yx/9UWWuNOW1n3VZ4f5axWfML7Lcg= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -1519,8 +1562,8 @@ google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= -google.golang.org/api v0.126.0 h1:q4GJq+cAdMAC7XP7njvQ4tvohGLiSlytuL4BQxbIZ+o= -google.golang.org/api v0.126.0/go.mod h1:mBwVAtz+87bEN6CbA1GtZPDOqY2R5ONPqJeIlvyo4Aw= +google.golang.org/api v0.153.0 h1:N1AwGhielyKFaUqH07/ZSIQR3uNPcV7NVw0vj+j4iR4= +google.golang.org/api v0.153.0/go.mod h1:3qNJX5eOmhiWYc67jRA/3GsDw97UFb5ivv7Y2PrriAY= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -1528,8 +1571,9 @@ google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7 google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c= google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= +google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= @@ -1568,10 +1612,8 @@ google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210126160654-44e461bb6506/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= @@ -1638,12 +1680,12 @@ google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqw google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= google.golang.org/genproto v0.0.0-20221025140454-527a21cfbd71/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= -google.golang.org/genproto v0.0.0-20230706204954-ccb25ca9f130 h1:Au6te5hbKUV8pIYWHqOUZ1pva5qK/rwbIhoXEUB9Lu8= -google.golang.org/genproto v0.0.0-20230706204954-ccb25ca9f130/go.mod h1:O9kGHb51iE/nOGvQaDUuadVYqovW56s5emA88lQnj6Y= -google.golang.org/genproto/googleapis/api v0.0.0-20230629202037-9506855d4529 h1:s5YSX+ZH5b5vS9rnpGymvIyMpLRJizowqDlOuyjXnTk= -google.golang.org/genproto/googleapis/api v0.0.0-20230629202037-9506855d4529/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= -google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98 h1:bVf09lpb+OJbByTj913DRJioFFAjf/ZGxEz7MajTp2U= -google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98/go.mod h1:TUfxEVdsvPg18p6AslUXFoLdpED4oBnGwyqk3dV1XzM= +google.golang.org/genproto v0.0.0-20231211222908-989df2bf70f3 h1:1hfbdAfFbkmpg41000wDVqr7jUpK/Yo+LPnIxxGzmkg= +google.golang.org/genproto v0.0.0-20231211222908-989df2bf70f3/go.mod h1:5RBcpGRxr25RbDzY5w+dmaqpSEvl8Gwl1x2CICf60ic= +google.golang.org/genproto/googleapis/api v0.0.0-20231120223509-83a465c0220f h1:2yNACc1O40tTnrsbk9Cv6oxiW8pxI/pXj0wRtdlYmgY= +google.golang.org/genproto/googleapis/api v0.0.0-20231120223509-83a465c0220f/go.mod h1:Uy9bTZJqmfrw2rIBxgGLnamc78euZULUBrLZ9XTITKI= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231212172506-995d672761c0 h1:/jFB8jK5R3Sq3i/lmeZO0cATSzFfZaJq1J2Euan3XKU= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231212172506-995d672761c0/go.mod h1:FUoWkonphQm3RhTS+kOEhF8h0iDpm4tdXolVCeZ9KKA= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM= @@ -1685,8 +1727,8 @@ google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACu google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= -google.golang.org/grpc v1.56.2 h1:fVRFRnXvU+x6C4IlHZewvJOVHoOv1TUuQyoRsYnB4bI= -google.golang.org/grpc v1.56.2/go.mod h1:I9bI3vqKfayGqPUAwGdOSu7kt6oIJLixfffKrpXqQ9s= +google.golang.org/grpc v1.60.1 h1:26+wFr+cNqSGFcOXcabYC0lUVJVRa2Sb2ortSK7VrEU= +google.golang.org/grpc v1.60.1/go.mod h1:OlCHIeLYqSSsLi6i49B5QGdzaMZK9+M7LXN2FKz4eGM= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= @@ -1703,8 +1745,8 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= -google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= -google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I= +google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= @@ -1737,9 +1779,8 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo= -gotest.tools/v3 v3.5.0 h1:Ljk6PdHdOhAb5aDMWXjDLMMhph+BpztA4v1QdqEW2eY= -gotest.tools/v3 v3.5.0/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU= +gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU= +gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU= honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= @@ -1750,12 +1791,14 @@ honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9 honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= nhooyr.io/websocket v1.8.6 h1:s+C3xAMLwGmlI31Nyn/eAehUlZPwfYZu2JXM621Q5/k= nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0= -pgregory.net/rapid v0.5.5 h1:jkgx1TjbQPD/feRoK+S/mXw9e1uj6WilpHrXJowi6oA= -pgregory.net/rapid v0.5.5/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= +pgregory.net/rapid v1.1.0 h1:CMa0sjHSru3puNx+J0MIAuiiEV4N0qj8/cMWGBBCsjw= +pgregory.net/rapid v1.1.0/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= -sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= -sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= +sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E= +sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU= diff --git a/go.work b/go.work index 9293d3087..d083f10ab 100644 --- a/go.work +++ b/go.work @@ -3,4 +3,4 @@ go 1.21 use ( . ./interchaintest -) +) \ No newline at end of file diff --git a/go.work.sum b/go.work.sum deleted file mode 100644 index 7367fa3db..000000000 --- a/go.work.sum +++ /dev/null @@ -1,1094 +0,0 @@ -4d63.com/gochecknoglobals v0.1.0/go.mod h1:wfdC5ZjKSPr7CybKEcgJhUOgeAQW1+7WcyK8OvUilfo= -bazil.org/fuse v0.0.0-20200407214033-5883e5a4b512/go.mod h1:FbcW6z/2VytnFDhZfumh8Ss8zxHE6qpMP5sHTRe0EaM= -cloud.google.com/go v0.105.0/go.mod h1:PrLgOJNe5nfE9UMxKxgXj4mD3voiP+YQ6gdt6KMFOKM= -cloud.google.com/go v0.107.0/go.mod h1:wpc2eNrD7hXUTy8EKS10jkxpZBjASrORK7goS+3YX2I= -cloud.google.com/go v0.110.2/go.mod h1:k04UEeEtb6ZBRTv3dZz4CeJC3jKGxyhl0sAiVVquxiw= -cloud.google.com/go/accessapproval v1.5.0/go.mod h1:HFy3tuiGvMdcd/u+Cu5b9NkO1pEICJ46IR82PoUdplw= -cloud.google.com/go/accessapproval v1.7.1/go.mod h1:JYczztsHRMK7NTXb6Xw+dwbs/WnOJxbo/2mTI+Kgg68= -cloud.google.com/go/accesscontextmanager v1.4.0/go.mod h1:/Kjh7BBu/Gh83sv+K60vN9QE5NJcd80sU33vIe2IFPE= -cloud.google.com/go/accesscontextmanager v1.8.1/go.mod h1:JFJHfvuaTC+++1iL1coPiG1eu5D24db2wXCDWDjIrxo= -cloud.google.com/go/aiplatform v1.27.0/go.mod h1:Bvxqtl40l0WImSb04d0hXFU7gDOiq9jQmorivIiWcKg= -cloud.google.com/go/aiplatform v1.45.0/go.mod h1:Iu2Q7sC7QGhXUeOhAj/oCK9a+ULz1O4AotZiqjQ8MYA= -cloud.google.com/go/analytics v0.21.2/go.mod h1:U8dcUtmDmjrmUTnnnRnI4m6zKn/yaA5N9RlEkYFHpQo= -cloud.google.com/go/apigateway v1.4.0/go.mod h1:pHVY9MKGaH9PQ3pJ4YLzoj6U5FUDeDFBllIz7WmzJoc= -cloud.google.com/go/apigateway v1.6.1/go.mod h1:ufAS3wpbRjqfZrzpvLC2oh0MFlpRJm2E/ts25yyqmXA= -cloud.google.com/go/apigeeconnect v1.4.0/go.mod h1:kV4NwOKqjvt2JYR0AoIWo2QGfoRtn/pkS3QlHp0Ni04= -cloud.google.com/go/apigeeconnect v1.6.1/go.mod h1:C4awq7x0JpLtrlQCr8AzVIzAaYgngRqWf9S5Uhg+wWs= -cloud.google.com/go/apigeeregistry v0.4.0/go.mod h1:EUG4PGcsZvxOXAdyEghIdXwAEi/4MEaoqLMLDMIwKXY= -cloud.google.com/go/apigeeregistry v0.7.1/go.mod h1:1XgyjZye4Mqtw7T9TsY4NW10U7BojBvG4RMD+vRDrIw= -cloud.google.com/go/apikeys v0.4.0/go.mod h1:XATS/yqZbaBK0HOssf+ALHp8jAlNHUgyfprvNcBIszU= -cloud.google.com/go/appengine v1.5.0/go.mod h1:TfasSozdkFI0zeoxW3PTBLiNqRmzraodCWatWI9Dmak= -cloud.google.com/go/appengine v1.8.1/go.mod h1:6NJXGLVhZCN9aQ/AEDvmfzKEfoYBlfB80/BHiKVputY= -cloud.google.com/go/area120 v0.8.1/go.mod h1:BVfZpGpB7KFVNxPiQBuHkX6Ed0rS51xIgmGyjrAfzsg= -cloud.google.com/go/artifactregistry v1.9.0/go.mod h1:2K2RqvA2CYvAeARHRkLDhMDJ3OXy26h3XW+3/Jh2uYc= -cloud.google.com/go/artifactregistry v1.14.1/go.mod h1:nxVdG19jTaSTu7yA7+VbWL346r3rIdkZ142BSQqhn5E= -cloud.google.com/go/asset v1.10.0/go.mod h1:pLz7uokL80qKhzKr4xXGvBQXnzHn5evJAEAtZiIb0wY= -cloud.google.com/go/asset v1.14.1/go.mod h1:4bEJ3dnHCqWCDbWJ/6Vn7GVI9LerSi7Rfdi03hd+WTQ= -cloud.google.com/go/assuredworkloads v1.9.0/go.mod h1:kFuI1P78bplYtT77Tb1hi0FMxM0vVpRC7VVoJC3ZoT0= -cloud.google.com/go/assuredworkloads v1.11.1/go.mod h1:+F04I52Pgn5nmPG36CWFtxmav6+7Q+c5QyJoL18Lry0= -cloud.google.com/go/automl v1.8.0/go.mod h1:xWx7G/aPEe/NP+qzYXktoBSDfjO+vnKMGgsApGJJquM= -cloud.google.com/go/automl v1.13.1/go.mod h1:1aowgAHWYZU27MybSCFiukPO7xnyawv7pt3zK4bheQE= -cloud.google.com/go/baremetalsolution v0.4.0/go.mod h1:BymplhAadOO/eBa7KewQ0Ppg4A4Wplbn+PsFKRLo0uI= -cloud.google.com/go/baremetalsolution v0.5.0/go.mod h1:dXGxEkmR9BMwxhzBhV0AioD0ULBmuLZI8CdwalUxuss= -cloud.google.com/go/batch v0.4.0/go.mod h1:WZkHnP43R/QCGQsZ+0JyG4i79ranE2u8xvjq/9+STPE= -cloud.google.com/go/batch v0.7.0/go.mod h1:vLZN95s6teRUqRQ4s3RLDsH8PvboqBK+rn1oevL159g= -cloud.google.com/go/beyondcorp v0.3.0/go.mod h1:E5U5lcrcXMsCuoDNyGrpyTm/hn7ne941Jz2vmksAxW8= -cloud.google.com/go/beyondcorp v0.6.1/go.mod h1:YhxDWw946SCbmcWo3fAhw3V4XZMSpQ/VYfcKGAEU8/4= -cloud.google.com/go/bigquery v1.44.0/go.mod h1:0Y33VqXTEsbamHJvJHdFmtqHvMIY28aK1+dFsvaChGc= -cloud.google.com/go/bigquery v1.52.0/go.mod h1:3b/iXjRQGU4nKa87cXeg6/gogLjO8C6PmuM8i5Bi/u4= -cloud.google.com/go/billing v1.7.0/go.mod h1:q457N3Hbj9lYwwRbnlD7vUpyjq6u5U1RAOArInEiD5Y= -cloud.google.com/go/billing v1.16.0/go.mod h1:y8vx09JSSJG02k5QxbycNRrN7FGZB6F3CAcgum7jvGA= -cloud.google.com/go/binaryauthorization v1.4.0/go.mod h1:tsSPQrBd77VLplV70GUhBf/Zm3FsKmgSqgm4UmiDItk= -cloud.google.com/go/binaryauthorization v1.6.1/go.mod h1:TKt4pa8xhowwffiBmbrbcxijJRZED4zrqnwZ1lKH51U= -cloud.google.com/go/certificatemanager v1.4.0/go.mod h1:vowpercVFyqs8ABSmrdV+GiFf2H/ch3KyudYQEMM590= -cloud.google.com/go/certificatemanager v1.7.1/go.mod h1:iW8J3nG6SaRYImIa+wXQ0g8IgoofDFRp5UMzaNk1UqI= -cloud.google.com/go/channel v1.9.0/go.mod h1:jcu05W0my9Vx4mt3/rEHpfxc9eKi9XwsdDL8yBMbKUk= -cloud.google.com/go/channel v1.16.0/go.mod h1:eN/q1PFSl5gyu0dYdmxNXscY/4Fi7ABmeHCJNf/oHmc= -cloud.google.com/go/cloudbuild v1.4.0/go.mod h1:5Qwa40LHiOXmz3386FrjrYM93rM/hdRr7b53sySrTqA= -cloud.google.com/go/cloudbuild v1.10.1/go.mod h1:lyJg7v97SUIPq4RC2sGsz/9tNczhyv2AjML/ci4ulzU= -cloud.google.com/go/clouddms v1.4.0/go.mod h1:Eh7sUGCC+aKry14O1NRljhjyrr0NFC0G2cjwX0cByRk= -cloud.google.com/go/clouddms v1.6.1/go.mod h1:Ygo1vL52Ov4TBZQquhz5fiw2CQ58gvu+PlS6PVXCpZI= -cloud.google.com/go/cloudtasks v1.8.0/go.mod h1:gQXUIwCSOI4yPVK7DgTVFiiP0ZW/eQkydWzwVMdHxrI= -cloud.google.com/go/cloudtasks v1.11.1/go.mod h1:a9udmnou9KO2iulGscKR0qBYjreuX8oHwpmFsKspEvM= -cloud.google.com/go/compute v1.14.0/go.mod h1:YfLtxrj9sU4Yxv+sXzZkyPjEyPBZfXHUvjxega5vAdo= -cloud.google.com/go/compute v1.15.1/go.mod h1:bjjoF/NtFUrkD/urWfdHaKuOPDR5nWIs63rR+SXhcpA= -cloud.google.com/go/compute v1.19.1/go.mod h1:6ylj3a05WF8leseCdIf77NK0g1ey+nj5IKd5/kvShxE= -cloud.google.com/go/compute v1.19.3/go.mod h1:qxvISKp/gYnXkSAD1ppcSOveRAmzxicEv/JlizULFrI= -cloud.google.com/go/compute/metadata v0.2.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= -cloud.google.com/go/contactcenterinsights v1.4.0/go.mod h1:L2YzkGbPsv+vMQMCADxJoT9YiTTnSEd6fEvCeHTYVck= -cloud.google.com/go/contactcenterinsights v1.9.1/go.mod h1:bsg/R7zGLYMVxFFzfh9ooLTruLRCG9fnzhH9KznHhbM= -cloud.google.com/go/container v1.7.0/go.mod h1:Dp5AHtmothHGX3DwwIHPgq45Y8KmNsgN3amoYfxVkLo= -cloud.google.com/go/container v1.22.1/go.mod h1:lTNExE2R7f+DLbAN+rJiKTisauFCaoDq6NURZ83eVH4= -cloud.google.com/go/containeranalysis v0.10.1/go.mod h1:Ya2jiILITMY68ZLPaogjmOMNkwsDrWBSTyBubGXO7j0= -cloud.google.com/go/datacatalog v1.8.0/go.mod h1:KYuoVOv9BM8EYz/4eMFxrr4DUKhGIOXxZoKYF5wdISM= -cloud.google.com/go/datacatalog v1.14.1/go.mod h1:d2CevwTG4yedZilwe+v3E3ZBDRMobQfSG/a6cCCN5R4= -cloud.google.com/go/dataflow v0.9.1/go.mod h1:Wp7s32QjYuQDWqJPFFlnBKhkAtiFpMTdg00qGbnIHVw= -cloud.google.com/go/dataform v0.5.0/go.mod h1:GFUYRe8IBa2hcomWplodVmUx/iTL0FrsauObOM3Ipr0= -cloud.google.com/go/dataform v0.8.1/go.mod h1:3BhPSiw8xmppbgzeBbmDvmSWlwouuJkXsXsb8UBih9M= -cloud.google.com/go/datafusion v1.5.0/go.mod h1:Kz+l1FGHB0J+4XF2fud96WMmRiq/wj8N9u007vyXZ2w= -cloud.google.com/go/datafusion v1.7.1/go.mod h1:KpoTBbFmoToDExJUso/fcCiguGDk7MEzOWXUsJo0wsI= -cloud.google.com/go/datalabeling v0.8.1/go.mod h1:XS62LBSVPbYR54GfYQsPXZjTW8UxCK2fkDciSrpRFdY= -cloud.google.com/go/dataplex v1.4.0/go.mod h1:X51GfLXEMVJ6UN47ESVqvlsRplbLhcsAt0kZCCKsU0A= -cloud.google.com/go/dataplex v1.8.1/go.mod h1:7TyrDT6BCdI8/38Uvp0/ZxBslOslP2X2MPDucliyvSE= -cloud.google.com/go/dataproc v1.8.0/go.mod h1:5OW+zNAH0pMpw14JVrPONsxMQYMBqJuzORhIBfBn9uI= -cloud.google.com/go/dataproc v1.12.0/go.mod h1:zrF3aX0uV3ikkMz6z4uBbIKyhRITnxvr4i3IjKsKrw4= -cloud.google.com/go/dataqna v0.8.1/go.mod h1:zxZM0Bl6liMePWsHA8RMGAfmTG34vJMapbHAxQ5+WA8= -cloud.google.com/go/datastore v1.10.0/go.mod h1:PC5UzAmDEkAmkfaknstTYbNpgE49HAgW2J1gcgUfmdM= -cloud.google.com/go/datastore v1.12.0/go.mod h1:KjdB88W897MRITkvWWJrg2OUtrR5XVj1EoLgSp6/N70= -cloud.google.com/go/datastream v1.5.0/go.mod h1:6TZMMNPwjUqZHBKPQ1wwXpb0d5VDVPl2/XoS5yi88q4= -cloud.google.com/go/datastream v1.9.1/go.mod h1:hqnmr8kdUBmrnk65k5wNRoHSCYksvpdZIcZIEl8h43Q= -cloud.google.com/go/deploy v1.5.0/go.mod h1:ffgdD0B89tToyW/U/D2eL0jN2+IEV/3EMuXHA0l4r+s= -cloud.google.com/go/deploy v1.11.0/go.mod h1:tKuSUV5pXbn67KiubiUNUejqLs4f5cxxiCNCeyl0F2g= -cloud.google.com/go/dialogflow v1.29.0/go.mod h1:b+2bzMe+k1s9V+F2jbJwpHPzrnIyHihAdRFMtn2WXuM= -cloud.google.com/go/dialogflow v1.38.0/go.mod h1:L7jnH+JL2mtmdChzAIcXQHXMvQkE3U4hTaNltEuxXn4= -cloud.google.com/go/dlp v1.7.0/go.mod h1:68ak9vCiMBjbasxeVD17hVPxDEck+ExiHavX8kiHG+Q= -cloud.google.com/go/dlp v1.10.1/go.mod h1:IM8BWz1iJd8njcNcG0+Kyd9OPnqnRNkDV8j42VT5KOI= -cloud.google.com/go/documentai v1.10.0/go.mod h1:vod47hKQIPeCfN2QS/jULIvQTugbmdc0ZvxxfQY1bg4= -cloud.google.com/go/documentai v1.20.0/go.mod h1:yJkInoMcK0qNAEdRnqY/D5asy73tnPe88I1YTZT+a8E= -cloud.google.com/go/domains v0.9.1/go.mod h1:aOp1c0MbejQQ2Pjf1iJvnVyT+z6R6s8pX66KaCSDYfE= -cloud.google.com/go/edgecontainer v1.1.1/go.mod h1:O5bYcS//7MELQZs3+7mabRqoWQhXCzenBu0R8bz2rwk= -cloud.google.com/go/errorreporting v0.3.0/go.mod h1:xsP2yaAp+OAW4OIm60An2bbLpqIhKXdWR/tawvl7QzU= -cloud.google.com/go/essentialcontacts v1.4.0/go.mod h1:8tRldvHYsmnBCHdFpvU+GL75oWiBKl80BiqlFh9tp+8= -cloud.google.com/go/essentialcontacts v1.6.2/go.mod h1:T2tB6tX+TRak7i88Fb2N9Ok3PvY3UNbUsMag9/BARh4= -cloud.google.com/go/eventarc v1.8.0/go.mod h1:imbzxkyAU4ubfsaKYdQg04WS1NvncblHEup4kvF+4gw= -cloud.google.com/go/eventarc v1.12.1/go.mod h1:mAFCW6lukH5+IZjkvrEss+jmt2kOdYlN8aMx3sRJiAI= -cloud.google.com/go/filestore v1.4.0/go.mod h1:PaG5oDfo9r224f8OYXURtAsY+Fbyq/bLYoINEK8XQAI= -cloud.google.com/go/filestore v1.7.1/go.mod h1:y10jsorq40JJnjR/lQ8AfFbbcGlw3g+Dp8oN7i7FjV4= -cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= -cloud.google.com/go/firestore v1.9.0/go.mod h1:HMkjKHNTtRyZNiMzu7YAsLr9K3X2udY2AMwDaMEQiiE= -cloud.google.com/go/firestore v1.11.0/go.mod h1:b38dKhgzlmNNGTNZZwe7ZRFEuRab1Hay3/DBsIGKKy4= -cloud.google.com/go/functions v1.9.0/go.mod h1:Y+Dz8yGguzO3PpIjhLTbnqV1CWmgQ5UwtlpzoyquQ08= -cloud.google.com/go/functions v1.15.1/go.mod h1:P5yNWUTkyU+LvW/S9O6V+V423VZooALQlqoXdoPz5AE= -cloud.google.com/go/gaming v1.8.0/go.mod h1:xAqjS8b7jAVW0KFYeRUxngo9My3f33kFmua++Pi+ggM= -cloud.google.com/go/gaming v1.10.1/go.mod h1:XQQvtfP8Rb9Rxnxm5wFVpAp9zCQkJi2bLIb7iHGwB3s= -cloud.google.com/go/gkebackup v0.3.0/go.mod h1:n/E671i1aOQvUxT541aTkCwExO/bTer2HDlj4TsBRAo= -cloud.google.com/go/gkebackup v0.4.0/go.mod h1:byAyBGUwYGEEww7xsbnUTBHIYcOPy/PgUWUtOeRm9Vg= -cloud.google.com/go/gkeconnect v0.8.1/go.mod h1:KWiK1g9sDLZqhxB2xEuPV8V9NYzrqTUmQR9shJHpOZw= -cloud.google.com/go/gkehub v0.14.1/go.mod h1:VEXKIJZ2avzrbd7u+zeMtW00Y8ddk/4V9511C9CQGTY= -cloud.google.com/go/gkemulticloud v0.4.0/go.mod h1:E9gxVBnseLWCk24ch+P9+B2CoDFJZTyIgLKSalC7tuI= -cloud.google.com/go/gkemulticloud v0.6.1/go.mod h1:kbZ3HKyTsiwqKX7Yw56+wUGwwNZViRnxWK2DVknXWfw= -cloud.google.com/go/gsuiteaddons v1.4.0/go.mod h1:rZK5I8hht7u7HxFQcFei0+AtfS9uSushomRlg+3ua1o= -cloud.google.com/go/gsuiteaddons v1.6.1/go.mod h1:CodrdOqRZcLp5WOwejHWYBjZvfY0kOphkAKpF/3qdZY= -cloud.google.com/go/iam v0.8.0/go.mod h1:lga0/y3iH6CX7sYqypWJ33hf7kkfXJag67naqGESjkE= -cloud.google.com/go/iam v0.11.0/go.mod h1:9PiLDanza5D+oWFZiH1uG+RnRCfEGKoyl6yo4cgWZGY= -cloud.google.com/go/iam v0.13.0/go.mod h1:ljOg+rcNfzZ5d6f1nAUJ8ZIxOaZUVoS14bKCtaLZ/D0= -cloud.google.com/go/iap v1.5.0/go.mod h1:UH/CGgKd4KyohZL5Pt0jSKE4m3FR51qg6FKQ/z/Ix9A= -cloud.google.com/go/iap v1.8.1/go.mod h1:sJCbeqg3mvWLqjZNsI6dfAtbbV1DL2Rl7e1mTyXYREQ= -cloud.google.com/go/ids v1.2.0/go.mod h1:5WXvp4n25S0rA/mQWAg1YEEBBq6/s+7ml1RDCW1IrcY= -cloud.google.com/go/ids v1.4.1/go.mod h1:np41ed8YMU8zOgv53MMMoCntLTn2lF+SUzlM+O3u/jw= -cloud.google.com/go/iot v1.4.0/go.mod h1:dIDxPOn0UvNDUMD8Ger7FIaTuvMkj+aGk94RPP0iV+g= -cloud.google.com/go/iot v1.7.1/go.mod h1:46Mgw7ev1k9KqK1ao0ayW9h0lI+3hxeanz+L1zmbbbk= -cloud.google.com/go/kms v1.6.0/go.mod h1:Jjy850yySiasBUDi6KFUwUv2n1+o7QZFyuUJg6OgjA0= -cloud.google.com/go/kms v1.12.1/go.mod h1:c9J991h5DTl+kg7gi3MYomh12YEENGrf48ee/N/2CDM= -cloud.google.com/go/language v1.8.0/go.mod h1:qYPVHf7SPoNNiCL2Dr0FfEFNil1qi3pQEyygwpgVKB8= -cloud.google.com/go/language v1.10.1/go.mod h1:CPp94nsdVNiQEt1CNjF5WkTcisLiHPyIbMhvR8H2AW0= -cloud.google.com/go/lifesciences v0.9.1/go.mod h1:hACAOd1fFbCGLr/+weUKRAJas82Y4vrL3O5326N//Wc= -cloud.google.com/go/logging v1.6.1/go.mod h1:5ZO0mHHbvm8gEmeEUHrmDlTDSu5imF6MUP9OfilNXBw= -cloud.google.com/go/logging v1.7.0/go.mod h1:3xjP2CjkM3ZkO73aj4ASA5wRPGGCRrPIAeNqVNkzY8M= -cloud.google.com/go/longrunning v0.3.0/go.mod h1:qth9Y41RRSUE69rDcOn6DdK3HfQfsUI0YSmW3iIlLJc= -cloud.google.com/go/longrunning v0.4.2/go.mod h1:OHrnaYyLUV6oqwh0xiS7e5sLQhP1m0QU9R+WhGDMgIQ= -cloud.google.com/go/longrunning v0.5.1/go.mod h1:spvimkwdz6SPWKEt/XBij79E9fiTkHSQl/fRUUQJYJc= -cloud.google.com/go/managedidentities v1.4.0/go.mod h1:NWSBYbEMgqmbZsLIyKvxrYbtqOsxY1ZrGM+9RgDqInM= -cloud.google.com/go/managedidentities v1.6.1/go.mod h1:h/irGhTN2SkZ64F43tfGPMbHnypMbu4RB3yl8YcuEak= -cloud.google.com/go/maps v0.1.0/go.mod h1:BQM97WGyfw9FWEmQMpZ5T6cpovXXSd1cGmFma94eubI= -cloud.google.com/go/maps v0.7.0/go.mod h1:3GnvVl3cqeSvgMcpRlQidXsPYuDGQ8naBis7MVzpXsY= -cloud.google.com/go/mediatranslation v0.8.1/go.mod h1:L/7hBdEYbYHQJhX2sldtTO5SZZ1C1vkapubj0T2aGig= -cloud.google.com/go/memcache v1.7.0/go.mod h1:ywMKfjWhNtkQTxrWxCkCFkoPjLHPW6A7WOTVI8xy3LY= -cloud.google.com/go/memcache v1.10.1/go.mod h1:47YRQIarv4I3QS5+hoETgKO40InqzLP6kpNLvyXuyaA= -cloud.google.com/go/metastore v1.8.0/go.mod h1:zHiMc4ZUpBiM7twCIFQmJ9JMEkDSyZS9U12uf7wHqSI= -cloud.google.com/go/metastore v1.11.1/go.mod h1:uZuSo80U3Wd4zi6C22ZZliOUJ3XeM/MlYi/z5OAOWRA= -cloud.google.com/go/monitoring v1.8.0/go.mod h1:E7PtoMJ1kQXWxPjB6mv2fhC5/15jInuulFdYYtlcvT4= -cloud.google.com/go/monitoring v1.15.1/go.mod h1:lADlSAlFdbqQuwwpaImhsJXu1QSdd3ojypXrFSMr2rM= -cloud.google.com/go/networkconnectivity v1.7.0/go.mod h1:RMuSbkdbPwNMQjB5HBWD5MpTBnNm39iAVpC3TmsExt8= -cloud.google.com/go/networkconnectivity v1.12.1/go.mod h1:PelxSWYM7Sh9/guf8CFhi6vIqf19Ir/sbfZRUwXh92E= -cloud.google.com/go/networkmanagement v1.5.0/go.mod h1:ZnOeZ/evzUdUsnvRt792H0uYEnHQEMaz+REhhzJRcf4= -cloud.google.com/go/networkmanagement v1.8.0/go.mod h1:Ho/BUGmtyEqrttTgWEe7m+8vDdK74ibQc+Be0q7Fof0= -cloud.google.com/go/networksecurity v0.9.1/go.mod h1:MCMdxOKQ30wsBI1eI659f9kEp4wuuAueoC9AJKSPWZQ= -cloud.google.com/go/notebooks v1.5.0/go.mod h1:q8mwhnP9aR8Hpfnrc5iN5IBhrXUy8S2vuYs+kBJ/gu0= -cloud.google.com/go/notebooks v1.9.1/go.mod h1:zqG9/gk05JrzgBt4ghLzEepPHNwE5jgPcHZRKhlC1A8= -cloud.google.com/go/optimization v1.2.0/go.mod h1:Lr7SOHdRDENsh+WXVmQhQTrzdu9ybg0NecjHidBq6xs= -cloud.google.com/go/optimization v1.4.1/go.mod h1:j64vZQP7h9bO49m2rVaTVoNM0vEBEN5eKPUPbZyXOrk= -cloud.google.com/go/orchestration v1.4.0/go.mod h1:6W5NLFWs2TlniBphAViZEVhrXRSMgUGDfW7vrWKvsBk= -cloud.google.com/go/orchestration v1.8.1/go.mod h1:4sluRF3wgbYVRqz7zJ1/EUNc90TTprliq9477fGobD8= -cloud.google.com/go/orgpolicy v1.5.0/go.mod h1:hZEc5q3wzwXJaKrsx5+Ewg0u1LxJ51nNFlext7Tanwc= -cloud.google.com/go/orgpolicy v1.11.1/go.mod h1:8+E3jQcpZJQliP+zaFfayC2Pg5bmhuLK755wKhIIUCE= -cloud.google.com/go/osconfig v1.10.0/go.mod h1:uMhCzqC5I8zfD9zDEAfvgVhDS8oIjySWh+l4WK6GnWw= -cloud.google.com/go/osconfig v1.12.1/go.mod h1:4CjBxND0gswz2gfYRCUoUzCm9zCABp91EeTtWXyz0tE= -cloud.google.com/go/oslogin v1.7.0/go.mod h1:e04SN0xO1UNJ1M5GP0vzVBFicIe4O53FOfcixIqTyXo= -cloud.google.com/go/oslogin v1.10.1/go.mod h1:x692z7yAue5nE7CsSnoG0aaMbNoRJRXO4sn73R+ZqAs= -cloud.google.com/go/phishingprotection v0.8.1/go.mod h1:AxonW7GovcA8qdEk13NfHq9hNx5KPtfxXNeUxTDxB6I= -cloud.google.com/go/policytroubleshooter v1.4.0/go.mod h1:DZT4BcRw3QoO8ota9xw/LKtPa8lKeCByYeKTIf/vxdE= -cloud.google.com/go/policytroubleshooter v1.7.1/go.mod h1:0NaT5v3Ag1M7U5r0GfDCpUFkWd9YqpubBWsQlhanRv0= -cloud.google.com/go/privatecatalog v0.9.1/go.mod h1:0XlDXW2unJXdf9zFz968Hp35gl/bhF4twwpXZAW50JA= -cloud.google.com/go/pubsub v1.27.1/go.mod h1:hQN39ymbV9geqBnfQq6Xf63yNhUAhv9CZhzp5O6qsW0= -cloud.google.com/go/pubsub v1.32.0/go.mod h1:f+w71I33OMyxf9VpMVcZbnG5KSUkCOUHYpFd5U1GdRc= -cloud.google.com/go/pubsublite v1.5.0/go.mod h1:xapqNQ1CuLfGi23Yda/9l4bBCKz/wC3KIJ5gKcxveZg= -cloud.google.com/go/pubsublite v1.8.1/go.mod h1:fOLdU4f5xldK4RGJrBMm+J7zMWNj/k4PxwEZXy39QS0= -cloud.google.com/go/recaptchaenterprise/v2 v2.5.0/go.mod h1:O8LzcHXN3rz0j+LBC91jrwI3R+1ZSZEWrfL7XHgNo9U= -cloud.google.com/go/recaptchaenterprise/v2 v2.7.2/go.mod h1:kR0KjsJS7Jt1YSyWFkseQ756D45kaYNTlDPPaRAvDBU= -cloud.google.com/go/recommendationengine v0.8.1/go.mod h1:MrZihWwtFYWDzE6Hz5nKcNz3gLizXVIDI/o3G1DLcrE= -cloud.google.com/go/recommender v1.8.0/go.mod h1:PkjXrTT05BFKwxaUxQmtIlrtj0kph108r02ZZQ5FE70= -cloud.google.com/go/recommender v1.10.1/go.mod h1:XFvrE4Suqn5Cq0Lf+mCP6oBHD/yRMA8XxP5sb7Q7gpA= -cloud.google.com/go/redis v1.10.0/go.mod h1:ThJf3mMBQtW18JzGgh41/Wld6vnDDc/F/F35UolRZPM= -cloud.google.com/go/redis v1.13.1/go.mod h1:VP7DGLpE91M6bcsDdMuyCm2hIpB6Vp2hI090Mfd1tcg= -cloud.google.com/go/resourcemanager v1.4.0/go.mod h1:MwxuzkumyTX7/a3n37gmsT3py7LIXwrShilPh3P1tR0= -cloud.google.com/go/resourcemanager v1.9.1/go.mod h1:dVCuosgrh1tINZ/RwBufr8lULmWGOkPS8gL5gqyjdT8= -cloud.google.com/go/resourcesettings v1.4.0/go.mod h1:ldiH9IJpcrlC3VSuCGvjR5of/ezRrOxFtpJoJo5SmXg= -cloud.google.com/go/resourcesettings v1.6.1/go.mod h1:M7mk9PIZrC5Fgsu1kZJci6mpgN8o0IUzVx3eJU3y4Jw= -cloud.google.com/go/retail v1.11.0/go.mod h1:MBLk1NaWPmh6iVFSz9MeKG/Psyd7TAgm6y/9L2B4x9Y= -cloud.google.com/go/retail v1.14.1/go.mod h1:y3Wv3Vr2k54dLNIrCzenyKG8g8dhvhncT2NcNjb/6gE= -cloud.google.com/go/run v0.3.0/go.mod h1:TuyY1+taHxTjrD0ZFk2iAR+xyOXEA0ztb7U3UNA0zBo= -cloud.google.com/go/run v0.9.0/go.mod h1:Wwu+/vvg8Y+JUApMwEDfVfhetv30hCG4ZwDR/IXl2Qg= -cloud.google.com/go/scheduler v1.7.0/go.mod h1:jyCiBqWW956uBjjPMMuX09n3x37mtyPJegEWKxRsn44= -cloud.google.com/go/scheduler v1.10.1/go.mod h1:R63Ldltd47Bs4gnhQkmNDse5w8gBRrhObZ54PxgR2Oo= -cloud.google.com/go/secretmanager v1.9.0/go.mod h1:b71qH2l1yHmWQHt9LC80akm86mX8AL6X1MA01dW8ht4= -cloud.google.com/go/secretmanager v1.11.1/go.mod h1:znq9JlXgTNdBeQk9TBW/FnR/W4uChEKGeqQWAJ8SXFw= -cloud.google.com/go/security v1.10.0/go.mod h1:QtOMZByJVlibUT2h9afNDWRZ1G96gVywH8T5GUSb9IA= -cloud.google.com/go/security v1.15.1/go.mod h1:MvTnnbsWnehoizHi09zoiZob0iCHVcL4AUBj76h9fXA= -cloud.google.com/go/securitycenter v1.16.0/go.mod h1:Q9GMaLQFUD+5ZTabrbujNWLtSLZIZF7SAR0wWECrjdk= -cloud.google.com/go/securitycenter v1.23.0/go.mod h1:8pwQ4n+Y9WCWM278R8W3nF65QtY172h4S8aXyI9/hsQ= -cloud.google.com/go/servicecontrol v1.5.0/go.mod h1:qM0CnXHhyqKVuiZnGKrIurvVImCs8gmqWsDoqe9sU1s= -cloud.google.com/go/servicedirectory v1.7.0/go.mod h1:5p/U5oyvgYGYejufvxhgwjL8UVXjkuw7q5XcG10wx1U= -cloud.google.com/go/servicedirectory v1.10.1/go.mod h1:Xv0YVH8s4pVOwfM/1eMTl0XJ6bzIOSLDt8f8eLaGOxQ= -cloud.google.com/go/servicemanagement v1.5.0/go.mod h1:XGaCRe57kfqu4+lRxaFEAuqmjzF0r+gWHjWqKqBvKFo= -cloud.google.com/go/serviceusage v1.4.0/go.mod h1:SB4yxXSaYVuUBYUml6qklyONXNLt83U0Rb+CXyhjEeU= -cloud.google.com/go/shell v1.4.0/go.mod h1:HDxPzZf3GkDdhExzD/gs8Grqk+dmYcEjGShZgYa9URw= -cloud.google.com/go/shell v1.7.1/go.mod h1:u1RaM+huXFaTojTbW4g9P5emOrrmLE69KrxqQahKn4g= -cloud.google.com/go/spanner v1.41.0/go.mod h1:MLYDBJR/dY4Wt7ZaMIQ7rXOTLjYrmxLE/5ve9vFfWos= -cloud.google.com/go/spanner v1.47.0/go.mod h1:IXsJwVW2j4UKs0eYDqodab6HgGuA1bViSqW4uH9lfUI= -cloud.google.com/go/speech v1.9.0/go.mod h1:xQ0jTcmnRFFM2RfX/U+rk6FQNUF6DQlydUSyoooSpco= -cloud.google.com/go/speech v1.17.1/go.mod h1:8rVNzU43tQvxDaGvqOhpDqgkJTFowBpDvCJ14kGlJYo= -cloud.google.com/go/storage v1.28.1/go.mod h1:Qnisd4CqDdo6BGs2AD5LLnEsmSQ80wQ5ogcBBKhU86Y= -cloud.google.com/go/storagetransfer v1.6.0/go.mod h1:y77xm4CQV/ZhFZH75PLEXY0ROiS7Gh6pSKrM8dJyg6I= -cloud.google.com/go/storagetransfer v1.10.0/go.mod h1:DM4sTlSmGiNczmV6iZyceIh2dbs+7z2Ayg6YAiQlYfA= -cloud.google.com/go/talent v1.4.0/go.mod h1:ezFtAgVuRf8jRsvyE6EwmbTK5LKciD4KVnHuDEFmOOA= -cloud.google.com/go/talent v1.6.2/go.mod h1:CbGvmKCG61mkdjcqTcLOkb2ZN1SrQI8MDyma2l7VD24= -cloud.google.com/go/texttospeech v1.5.0/go.mod h1:oKPLhR4n4ZdQqWKURdwxMy0uiTS1xU161C8W57Wkea4= -cloud.google.com/go/texttospeech v1.7.1/go.mod h1:m7QfG5IXxeneGqTapXNxv2ItxP/FS0hCZBwXYqucgSk= -cloud.google.com/go/tpu v1.4.0/go.mod h1:mjZaX8p0VBgllCzF6wcU2ovUXN9TONFLd7iz227X2Xg= -cloud.google.com/go/tpu v1.6.1/go.mod h1:sOdcHVIgDEEOKuqUoi6Fq53MKHJAtOwtz0GuKsWSH3E= -cloud.google.com/go/trace v1.4.0/go.mod h1:UG0v8UBqzusp+z63o7FK74SdFE+AXpCLdFb1rshXG+Y= -cloud.google.com/go/trace v1.10.1/go.mod h1:gbtL94KE5AJLH3y+WVpfWILmqgc6dXcqgNXdOPAQTYk= -cloud.google.com/go/translate v1.4.0/go.mod h1:06Dn/ppvLD6WvA5Rhdp029IX2Mi3Mn7fpMRLPvXT5Wg= -cloud.google.com/go/translate v1.8.1/go.mod h1:d1ZH5aaOA0CNhWeXeC8ujd4tdCFw8XoNWRljklu5RHs= -cloud.google.com/go/video v1.9.0/go.mod h1:0RhNKFRF5v92f8dQt0yhaHrEuH95m068JYOvLZYnJSw= -cloud.google.com/go/video v1.17.1/go.mod h1:9qmqPqw/Ib2tLqaeHgtakU+l5TcJxCJbhFXM7UJjVzU= -cloud.google.com/go/videointelligence v1.9.0/go.mod h1:29lVRMPDYHikk3v8EdPSaL8Ku+eMzDljjuvRs105XoU= -cloud.google.com/go/videointelligence v1.11.1/go.mod h1:76xn/8InyQHarjTWsBR058SmlPCwQjgcvoW0aZykOvo= -cloud.google.com/go/vision/v2 v2.5.0/go.mod h1:MmaezXOOE+IWa+cS7OhRRLK2cNv1ZL98zhqFFZaaH2E= -cloud.google.com/go/vision/v2 v2.7.2/go.mod h1:jKa8oSYBWhYiXarHPvP4USxYANYUEdEsQrloLjrSwJU= -cloud.google.com/go/vmmigration v1.3.0/go.mod h1:oGJ6ZgGPQOFdjHuocGcLqX4lc98YQ7Ygq8YQwHh9A7g= -cloud.google.com/go/vmmigration v1.7.1/go.mod h1:WD+5z7a/IpZ5bKK//YmT9E047AD+rjycCAvyMxGJbro= -cloud.google.com/go/vmwareengine v0.1.0/go.mod h1:RsdNEf/8UDvKllXhMz5J40XxDrNJNN4sagiox+OI208= -cloud.google.com/go/vmwareengine v0.4.1/go.mod h1:Px64x+BvjPZwWuc4HdmVhoygcXqEkGHXoa7uyfTgSI0= -cloud.google.com/go/vpcaccess v1.5.0/go.mod h1:drmg4HLk9NkZpGfCmZ3Tz0Bwnm2+DKqViEpeEpOq0m8= -cloud.google.com/go/vpcaccess v1.7.1/go.mod h1:FogoD46/ZU+JUBX9D606X21EnxiszYi2tArQwLY4SXs= -cloud.google.com/go/webrisk v1.7.0/go.mod h1:mVMHgEYH0r337nmt1JyLthzMr6YxwN1aAIEc2fTcq7A= -cloud.google.com/go/webrisk v1.9.1/go.mod h1:4GCmXKcOa2BZcZPn6DCEvE7HypmEJcJkr4mtM+sqYPc= -cloud.google.com/go/websecurityscanner v1.4.0/go.mod h1:ebit/Fp0a+FWu5j4JOmJEV8S8CzdTkAS77oDsiSqYWQ= -cloud.google.com/go/websecurityscanner v1.6.1/go.mod h1:Njgaw3rttgRHXzwCB8kgCYqv5/rGpFCsBOvPbYgszpg= -cloud.google.com/go/workflows v1.9.0/go.mod h1:ZGkj1aFIOd9c8Gerkjjq7OW7I5+l6cSvT3ujaO/WwSA= -cloud.google.com/go/workflows v1.11.1/go.mod h1:Z+t10G1wF7h8LgdY/EmRcQY8ptBD/nvofaL6FqlET6g= -cosmossdk.io/api v0.2.6/go.mod h1:u/d+GAxil0nWpl1XnQL8nkziQDIWuBDhv8VnDm/s6dI= -cosmossdk.io/core v0.3.2/go.mod h1:CO7vbe+evrBvHc0setFHL/u7nlY7HJGzdRSBkT/sirc= -cosmossdk.io/math v1.0.0-beta.4/go.mod h1:An0MllWJY6PxibUpnwGk8jOm+a/qIxlKmL5Zyp9NnaM= -github.com/Abirdcfly/dupword v0.0.7/go.mod h1:K/4M1kj+Zh39d2aotRwypvasonOyAMH1c/IZJzE0dmk= -github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8= -github.com/Antonboom/errname v0.1.7/go.mod h1:g0ONh16msHIPgJSGsecu1G/dcF2hlYR/0SddnIAGavU= -github.com/Antonboom/nilnil v0.1.1/go.mod h1:L1jBqoWM7AOeTD+tSquifKSesRHs4ZdaxvZR+xdJEaI= -github.com/Azure/azure-sdk-for-go/sdk/azcore v0.21.1/go.mod h1:fBF9PQNqB8scdgpZ3ufzaLntG0AG7C1WjPMsiFOmfHM= -github.com/Azure/azure-sdk-for-go/sdk/internal v0.8.3/go.mod h1:KLF4gFr6DcKFZwSuH8w8yEK6DpFl3LP5rhdvAb7Yz5I= -github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v0.3.0/go.mod h1:tPaiy8S5bQ+S5sOiDlINkp7+Ef339+Nz5L5XO+cnOHo= -github.com/Azure/go-ansiterm v0.0.0-20210608223527-2377c96fe795/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8= -github.com/Azure/go-autorest/autorest v0.11.18/go.mod h1:dSiJPy22c3u0OtOKDNttNgqpNFY/GeWa7GH/Pz56QRA= -github.com/Azure/go-autorest/autorest/adal v0.9.13/go.mod h1:W/MM4U6nLxnIskrw4UwWzlHfGjwUS50aOsc/I3yuU8M= -github.com/Azure/go-autorest/logger v0.2.1/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZmbF5NWuPV8+WeEW8= -github.com/CloudyKit/fastprinter v0.0.0-20170127035650-74b38d55f37a/go.mod h1:EFZQ978U7x8IRnstaskI3IysnWY5Ao3QgZUKOXlsAdw= -github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3IMCy2vIlbG1XG/0ggNQv0SvxCAIpPM5b1nCz56Xno= -github.com/CloudyKit/jet v2.1.3-0.20180809161101-62edd43e4f88+incompatible/go.mod h1:HPYO+50pSWkPoj9Q/eq0aRGByCL6ScRlUmiEX5Zgm+w= -github.com/CloudyKit/jet/v3 v3.0.0/go.mod h1:HKQPgSJmdK8hdoAbKUUWajkHyHo4RaU5rMdUywE7VMo= -github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= -github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= -github.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24/go.mod h1:4UJr5HIiMZrwgkSPdsjy2uOQExX/WEILpIrO9UPGuXs= -github.com/GaijinEntertainment/go-exhaustruct/v2 v2.3.0/go.mod h1:b3g59n2Y+T5xmcxJL+UEG2f8cQploZm1mR/v6BW0mU0= -github.com/HdrHistogram/hdrhistogram-go v1.1.2/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo= -github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY= -github.com/Joker/jade v1.0.1-0.20190614124447-d475f43051e7/go.mod h1:6E6s8o2AE4KhCrqr6GRJjdC/gNfTdxkIXvuGZZda2VM= -github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y= -github.com/Masterminds/semver/v3 v3.2.0/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ= -github.com/Microsoft/go-winio v0.5.1/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= -github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= -github.com/Microsoft/hcsshim v0.8.20/go.mod h1:+w2gRZ5ReXQhFOrvSQeNfhrYB/dg3oDwTOcER2fw4I4= -github.com/Microsoft/hcsshim v0.8.23/go.mod h1:4zegtUJth7lAvFyc6cH2gGQ5B3OFQim01nnU2M8jKDg= -github.com/Microsoft/hcsshim v0.9.2/go.mod h1:7pLA8lDk46WKDWlVsENo92gC0XFa8rbKfyFRBqxEbCc= -github.com/NYTimes/gziphandler v1.1.1/go.mod h1:n/CVRwUEOgIxrgPvAQhUUr9oeUtvrhMomdKFjzJNB0c= -github.com/OpenPeeDeeP/depguard v1.1.1/go.mod h1:JtAMzWkmFEzDPyAd+W0NHl1lvpQKTvT9jnRVsohBKpc= -github.com/ProtonMail/go-crypto v0.0.0-20221026131551-cf6655e29de4/go.mod h1:UBYPn8k0D56RtnR8RFQMjmh4KrZzWJ5o7Z9SYjossQ8= -github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0= -github.com/acomagu/bufpipe v1.0.3/go.mod h1:mxdxdup/WdsKVreO5GpW4+M/1CE2sMG4jeGJ2sYmHc4= -github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY= -github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw= -github.com/alexflint/go-filemutex v1.1.0/go.mod h1:7P4iRhttt/nUvUOrYIhcpMzv2G6CY9UnI16Z+UJqRyk= -github.com/alexkohler/prealloc v1.0.0/go.mod h1:VetnK3dIgFBBKmg0YnD9F9x6Icjd+9cvfHR56wJVlKE= -github.com/alingse/asasalint v0.0.11/go.mod h1:nCaoMhw7a9kSJObvQyVzNTPBDbNpdocqrSP7t/cW5+I= -github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4= -github.com/armon/go-metrics v0.4.0/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4= -github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= -github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= -github.com/ashanbrown/forbidigo v1.3.0/go.mod h1:vVW7PEdqEFqapJe95xHkTfB1+XvZXBFg8t0sG2FIxmI= -github.com/ashanbrown/makezero v1.1.1/go.mod h1:i1bJLCRSCHOcOa9Y6MyF2FTfMZMFdHvxKHxgO5Z1axI= -github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= -github.com/aws/aws-sdk-go-v2 v1.9.1/go.mod h1:cK/D0BBs0b/oWPIcX/Z/obahJK1TT7IPVjy53i/mX/4= -github.com/aws/aws-sdk-go-v2/config v1.1.1/go.mod h1:0XsVy9lBI/BCXm+2Tuvt39YmdHwS5unDQmxZOYe8F5Y= -github.com/aws/aws-sdk-go-v2/credentials v1.1.1/go.mod h1:mM2iIjwl7LULWtS6JCACyInboHirisUUdkBPoTHMOUo= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.0.2/go.mod h1:3hGg3PpiEjHnrkrlasTfxFqUsZ2GCk/fMUn4CbKgSkM= -github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.8.1/go.mod h1:CM+19rL1+4dFWnOQKwDc7H1KwXTz+h61oUSHyhV0b3o= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.0.2/go.mod h1:45MfaXZ0cNbeuT0KQ1XJylq8A6+OpVV2E5kvY/Kq+u8= -github.com/aws/aws-sdk-go-v2/service/route53 v1.1.1/go.mod h1:rLiOUrPLW/Er5kRcQ7NkwbjlijluLsrIbu/iyl35RO4= -github.com/aws/aws-sdk-go-v2/service/sso v1.1.1/go.mod h1:SuZJxklHxLAXgLTc1iFXbEWkXs7QRTQpCLGaKIprQW0= -github.com/aws/aws-sdk-go-v2/service/sts v1.1.1/go.mod h1:Wi0EBZwiz/K44YliU0EKxqTCJGUfYTWXrrBwkq736bM= -github.com/aws/smithy-go v1.8.0/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= -github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g= -github.com/benbjohnson/clock v1.0.3/go.mod h1:bGMdMPoPVvcYyt1gHDf4J2KE153Yf9BuiUKYMaxlTDM= -github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= -github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84= -github.com/bkielbasa/cyclop v1.2.0/go.mod h1:qOI0yy6A7dYC4Zgsa72Ppm9kONl0RoIlPbzot9mhmeI= -github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= -github.com/blizzy78/varnamelen v0.8.0/go.mod h1:V9TzQZ4fLJ1DSrjVDfl89H7aMnTvKkApdHeyESmyR7k= -github.com/bombsimon/wsl/v3 v3.3.0/go.mod h1:st10JtZYLE4D5sC7b8xV4zTKZwAQjCH/Hy2Pm1FNZIc= -github.com/breml/bidichk v0.2.3/go.mod h1:8u2C6DnAy0g2cEq+k/A2+tr9O1s+vHGxWn0LTc70T2A= -github.com/breml/errchkjson v0.3.0/go.mod h1:9Cogkyv9gcT8HREpzi3TiqBxCqDzo8awa92zSDFcofU= -github.com/btcsuite/btcd v0.23.0 h1:V2/ZgjfDFIygAX3ZapeigkVBoVUtOJKSwrhZdlpSvaA= -github.com/btcsuite/btcd/btcec/v2 v2.1.1/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE= -github.com/btcsuite/btcd/btcec/v2 v2.2.1/go.mod h1:9/CSmJxmuvqzX9Wh2fXMWToLOHhPd11lSPuIupwTkI8= -github.com/btcsuite/btcd/btcutil v1.1.1 h1:hDcDaXiP0uEzR8Biqo2weECKqEw0uHDZ9ixIWevVQqY= -github.com/btcsuite/btcd/btcutil v1.1.1/go.mod h1:nbKlBMNm9FGsdvKvu0essceubPiAcI57pYBNnsLAa34= -github.com/btcsuite/btcd/btcutil v1.1.2/go.mod h1:UR7dsSJzJUfMmFiiLlIrMq1lS9jh9EdCV7FStZSnpi0= -github.com/bufbuild/buf v1.7.0/go.mod h1:Go40fMAF46PnPLC7jJgTQhAI95pmC0+VtxFKVC0qLq0= -github.com/bufbuild/connect-go v1.0.0/go.mod h1:9iNvh/NOsfhNBUH5CtvXeVUskQO1xsrEviH7ZArwZ3I= -github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= -github.com/butuzov/ireturn v0.1.1/go.mod h1:Wh6Zl3IMtTpaIKbmwzqi6olnM9ptYQxxVacMsOEFPoc= -github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= -github.com/casbin/casbin/v2 v2.37.0/go.mod h1:vByNa/Fchek0KZUgG5wEsl7iFsiviAYKRtgrQfcJqHg= -github.com/cenkalti/backoff/v4 v4.1.2/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw= -github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw= -github.com/certifi/gocertifi v0.0.0-20191021191039-0944d244cd40/go.mod h1:sGbDF6GwGcLpkNXPUTkMRoywsNa/ol15pxFe6ERfguA= -github.com/certifi/gocertifi v0.0.0-20200922220541-2c3bb06c6054/go.mod h1:sGbDF6GwGcLpkNXPUTkMRoywsNa/ol15pxFe6ERfguA= -github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= -github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/charithe/durationcheck v0.0.9/go.mod h1:SSbRIBVfMjCi/kEB6K65XEA83D6prSM8ap1UCpNKtgg= -github.com/chavacava/garif v0.0.0-20220630083739-93517212f375/go.mod h1:4m1Rv7xfuwWPNKXlThldNuJvutYM6J95wNuuVmn55To= -github.com/clbanning/mxj v1.8.4/go.mod h1:BVjHeAH+rl9rs6f+QIpeRl0tfu10SXn1pUSa5PVGJng= -github.com/cloudflare/circl v1.1.0/go.mod h1:prBCrKB9DV4poKZY1l9zBXg2QJY7mvgRvtMxxK7fi4I= -github.com/cloudflare/cloudflare-go v0.14.0/go.mod h1:EnwdgGMaFOruiPZRFSgn+TsQ3hQ7C/YWzIGLeu5c304= -github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= -github.com/cncf/xds/go v0.0.0-20220314180256-7f1daf1720fc/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20230105202645-06c439db220b/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cockroachdb/datadriven v0.0.0-20200714090401-bf6692d28da5/go.mod h1:h6jFvWxBdQXxjopDMZyH2UVceIRfR84bdzbkoKrsWNo= -github.com/cockroachdb/datadriven v1.0.0/go.mod h1:5Ib8Meh+jk1RlHIXej6Pzevx/NLlNvQB9pmSBZErGA4= -github.com/cockroachdb/datadriven v1.0.2/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= -github.com/cockroachdb/errors v1.2.4/go.mod h1:rQD95gz6FARkaKkQXUksEje/d9a6wBJoCr5oaCLELYA= -github.com/cockroachdb/errors v1.6.1/go.mod h1:tm6FTP5G81vwJ5lC0SizQo374JNCOPrHyXGitRJoDqM= -github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac= -github.com/cockroachdb/errors v1.9.1/go.mod h1:2sxOtL2WIc096WSZqZ5h8fa17rdDq9HZOZLBCor4mBk= -github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= -github.com/cockroachdb/logtags v0.0.0-20211118104740-dabe8e521a4f/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= -github.com/cockroachdb/pebble v0.0.0-20220817183557-09c6e030a677/go.mod h1:890yq1fUb9b6dGNwssgeUO5vQV9qfXnCPxAJhBQfXw0= -github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= -github.com/cockroachdb/redact v1.1.3/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= -github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ= -github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM= -github.com/consensys/gnark-crypto v0.4.1-0.20210426202927-39ac3d4b3f1f/go.mod h1:815PAHg3wvysy0SyIqanF8gZ0Y1wjk/hrDHD/iT88+Q= -github.com/containerd/aufs v1.0.0/go.mod h1:kL5kd6KM5TzQjR79jljyi4olc1Vrx6XBlcyj3gNv2PU= -github.com/containerd/btrfs v1.0.0/go.mod h1:zMcX3qkXTAi9GI50+0HOeuV8LU2ryCE/V2vG/ZBiTss= -github.com/containerd/cgroups v1.0.3/go.mod h1:/ofk34relqNjSGyqPrmEULrO4Sc8LJhvJmWbUCUKqj8= -github.com/containerd/cgroups v1.0.4/go.mod h1:nLNQtsF7Sl2HxNebu77i1R0oDlhiTG+kO4JTrUzo6IA= -github.com/containerd/containerd v1.4.9/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= -github.com/containerd/containerd v1.5.8/go.mod h1:YdFSv5bTFLpG2HIYmfqDpSYYTDX+mc5qtSuYx1YUb/s= -github.com/containerd/containerd v1.6.1/go.mod h1:1nJz5xCZPusx6jJU8Frfct988y0NpumIq9ODB0kLtoE= -github.com/containerd/continuity v0.2.2/go.mod h1:pWygW9u7LtS1o4N/Tn0FoCFDIXZ7rxcMX7HX1Dmibvk= -github.com/containerd/fifo v1.0.0/go.mod h1:ocF/ME1SX5b1AOlWi9r677YJmCPSwwWnQ9O123vzpE4= -github.com/containerd/go-cni v1.1.0/go.mod h1:Rflh2EJ/++BA2/vY5ao3K6WJRR/bZKsX123aPk+kUtA= -github.com/containerd/go-cni v1.1.3/go.mod h1:Rflh2EJ/++BA2/vY5ao3K6WJRR/bZKsX123aPk+kUtA= -github.com/containerd/go-cni v1.1.6/go.mod h1:BWtoWl5ghVymxu6MBjg79W9NZrCRyHIdUtk4cauMe34= -github.com/containerd/go-runc v1.0.0/go.mod h1:cNU0ZbCgCQVZK4lgG3P+9tn9/PaJNmoDXPpoJhDR+Ok= -github.com/containerd/imgcrypt v1.1.3/go.mod h1:/TPA1GIDXMzbj01yd8pIbQiLdQxed5ue1wb8bP7PQu4= -github.com/containerd/imgcrypt v1.1.4/go.mod h1:LorQnPtzL/T0IyCeftcsMEO7AqxUDbdO8j/tSUpgxvo= -github.com/containerd/nri v0.1.0/go.mod h1:lmxnXF6oMkbqs39FiCt1s0R2HSMhcLel9vNL3m4AaeY= -github.com/containerd/ttrpc v1.1.0/go.mod h1:XX4ZTnoOId4HklF4edwc4DcqskFZuvXB1Evzy5KFQpQ= -github.com/containerd/typeurl v1.0.2/go.mod h1:9trJWW2sRlGub4wZJRTW83VtbOLS6hwcDZXTn6oPz9s= -github.com/containerd/zfs v1.0.0/go.mod h1:m+m51S1DvAP6r3FcmYCp54bQ34pyOwTieQDNRIRHsFY= -github.com/containernetworking/cni v1.0.1/go.mod h1:AKuhXbN5EzmD4yTNtfSsX3tPcmtrBI6QcRV0NiNt15Y= -github.com/containernetworking/cni v1.1.1/go.mod h1:sDpYKmGVENF3s6uvMvGgldDWeG8dMxakj/u+i9ht9vw= -github.com/containernetworking/plugins v1.0.1/go.mod h1:QHCfGpaTwYTbbH+nZXKVTxNBDZcxSOplJT5ico8/FLE= -github.com/containernetworking/plugins v1.1.1/go.mod h1:Sr5TH/eBsGLXK/h71HeLfX19sZPp3ry5uHSkI4LPxV8= -github.com/containers/ocicrypt v1.1.2/go.mod h1:Dm55fwWm1YZAjYRaJ94z2mfZikIyIN4B0oB3dj3jFxY= -github.com/containers/ocicrypt v1.1.3/go.mod h1:xpdkbVAuaH3WzbEabUd5yDsl9SwJA5pABH85425Es2g= -github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= -github.com/coreos/go-iptables v0.6.0/go.mod h1:Qe8Bv2Xik5FyTXwgIbLAnv2sWSBmvWdFETJConOQ//Q= -github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= -github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= -github.com/cosmos/cosmos-db v0.0.0-20221226095112-f3c38ecb5e32/go.mod h1:kwMlEC4wWvB48zAShGKVqboJL6w4zCLesaNQ3YLU2BQ= -github.com/cosmos/cosmos-proto v1.0.0-beta.1/go.mod h1:8k2GNZghi5sDRFw/scPL8gMSowT1vDA+5ouxL8GjaUE= -github.com/cosmos/cosmos-sdk/db v1.0.0-beta.1.0.20220726092710-f848e4300a8a/go.mod h1:c8IO23vgNxueCCJlSI9awQtcxsvc+buzaeThB85qfBU= -github.com/cosmos/gogoproto v1.4.1/go.mod h1:Ac9lzL4vFpBMcptJROQ6dQ4M3pOEK5Z/l0Q9p+LoCr4= -github.com/cosmos/gogoproto v1.4.3/go.mod h1:0hLIG5TR7IvV1fme1HCFKjfzW9X2x0Mo+RooWXCnOWU= -github.com/cosmos/gogoproto v1.4.4/go.mod h1:/yl6/nLwsZcZ2JY3OrqjRqvqCG9InUMcXRfRjQiF9DU= -github.com/cosmos/gorocksdb v1.2.0/go.mod h1:aaKvKItm514hKfNJpUJXnnOWeBnk2GL4+Qw9NHizILw= -github.com/cosmos/ledger-cosmos-go v0.12.1/go.mod h1:dhO6kj+Y+AHIOgAe4L9HL/6NDdyyth4q238I9yFpD2g= -github.com/creachadair/taskgroup v0.3.2/go.mod h1:wieWwecHVzsidg2CsUnFinW1faVN4+kq+TDlRJQ0Wbk= -github.com/creack/pty v1.1.11/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/cristalhq/acmd v0.8.1/go.mod h1:LG5oa43pE/BbxtfMoImHCQN++0Su7dzipdgBjMCBVDQ= -github.com/curioswitch/go-reassign v0.2.0/go.mod h1:x6OpXuWvgfQaMGks2BZybTngWjT84hqJfKoO8Tt/Roc= -github.com/daixiang0/gci v0.8.1/go.mod h1:EpVfrztufwVgQRXjnX4zuNinEpLj5OmMjtu/+MB0V0c= -github.com/deepmap/oapi-codegen v1.8.2/go.mod h1:YLgSKSDv/bZQB7N4ws6luhozi3cEdRktEqrX88CvjIw= -github.com/denis-tingaikin/go-header v0.4.3/go.mod h1:0wOCWuN71D5qIgE2nz9KrKmuYBAC2Mra5RassOIQ2/c= -github.com/denisenkom/go-mssqldb v0.12.0/go.mod h1:iiK0YP1ZeepvmBQk/QpLEhhTNJgfzrpArPY/aFvc9yU= -github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4= -github.com/dgraph-io/badger/v3 v3.2103.2/go.mod h1:RHo4/GmYcKKh5Lxu63wLEMHJ70Pac2JqZRYGhlyAo2M= -github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc= -github.com/docker/cli v20.10.17+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= -github.com/docker/docker v20.10.19+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= -github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c/go.mod h1:Uw6UezgYA44ePAFQYUehOuCzmy5zmg/+nl2ZfMWGkpA= -github.com/docker/go-metrics v0.0.1/go.mod h1:cG1hvH2utMXtqgqqYE9plW6lDxS3/5ayHzueweSI3Vw= -github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM= -github.com/emicklei/go-restful v2.9.5+incompatible/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs= -github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= -github.com/envoyproxy/go-control-plane v0.10.3/go.mod h1:fJJn/j26vwOu972OllsvAgJJM//w9BV6Fxbg2LuVd34= -github.com/envoyproxy/go-control-plane v0.11.1-0.20230524094728-9239064ad72f/go.mod h1:sfYdkwUW4BA3PbKjySwjJy+O4Pu0h62rlqCMHNk+K+Q= -github.com/envoyproxy/protoc-gen-validate v0.6.7/go.mod h1:dyJXwwfPK2VSqiB9Klm1J6romD608Ba7Hij42vrOBCo= -github.com/envoyproxy/protoc-gen-validate v0.9.1/go.mod h1:OKNgG7TCp5pF4d6XftA0++PMirau2/yoOwVac3AbF2w= -github.com/envoyproxy/protoc-gen-validate v0.10.1/go.mod h1:DRjgyB0I43LtJapqN6NiRwroiAU2PaFuvk/vjgh61ss= -github.com/esimonov/ifshort v1.0.4/go.mod h1:Pe8zjlRrJ80+q2CxHLfEOfTwxCZ4O+MuhcHcfgNWTk0= -github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw= -github.com/ettle/strcase v0.1.1/go.mod h1:hzDLsPC7/lwKyBOywSHEP89nt2pDgdy+No1NBA9o9VY= -github.com/evanphx/json-patch v4.11.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= -github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c/go.mod h1:Yg+htXGokKKdzcwhuNDwVvN+uBxDGXJ7G/VN1d8fa64= -github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg= -github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4/go.mod h1:5tD+neXqOorC30/tWg0LCSkrqj/AR6gu8yY8/fpw1q0= -github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8= -github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= -github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= -github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M= -github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94= -github.com/firefart/nonamedreturns v1.0.4/go.mod h1:TDhe/tjI1BXo48CmYbUduTV7BdIga8MAO/xbKdcVsGI= -github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= -github.com/flosch/pongo2 v0.0.0-20190707114632-bbf5a6c351f4/go.mod h1:T9YF2M40nIgbVgp3rreNmTged+9HrbNTIQf1PsaIiTA= -github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= -github.com/form3tech-oss/jwt-go v3.2.3+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k= -github.com/frankban/quicktest v1.14.3/go.mod h1:mgiwOwqx65TmIk1wJ6Q7wvnVMocbUorkibMOrVTHZps= -github.com/fzipp/gocyclo v0.6.0/go.mod h1:rXPyn8fnlpa0R2csP/31uerbiVBugk5whMdlyaLkLoA= -github.com/gavv/httpexpect v2.0.0+incompatible/go.mod h1:x+9tiU1YnrOvnB725RkpoLv1M62hOWzwo5OXotisrKc= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= -github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg= -github.com/getsentry/raven-go v0.2.0/go.mod h1:KungGk8q33+aIAZUIVWZDr2OfAEBsO49PX4NzFV5kcQ= -github.com/getsentry/sentry-go v0.12.0/go.mod h1:NSap0JBYWzHND8oMbyi0+XZhUalc1TBdRL1M71JZW2c= -github.com/getsentry/sentry-go v0.17.0/go.mod h1:B82dxtBvxG0KaPD8/hfSV+VcHD+Lg/xUS4JuQn1P4cM= -github.com/ghemawat/stream v0.0.0-20171120220530-696b145b53b9/go.mod h1:106OIgooyS7OzLDOpUGgm9fA3bQENb/cFSyyBmMoJDs= -github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s= -github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM= -github.com/gliderlabs/ssh v0.3.5/go.mod h1:8XB4KraRrX39qHhT6yxPsHedjA08I/uBVwj4xC+/+z4= -github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98= -github.com/go-chi/chi/v5 v5.0.7/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8= -github.com/go-critic/go-critic v0.6.5/go.mod h1:ezfP/Lh7MA6dBNn4c6ab5ALv3sKnZVLx37tr00uuaOY= -github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q= -github.com/go-git/gcfg v1.5.0/go.mod h1:5m20vg6GwYabIxaOonVkTdrILxQMpEShl1xiMF4ua+E= -github.com/go-git/go-billy/v5 v5.3.1/go.mod h1:pmpqyWchKfYfrkb/UVH4otLvyi/5gJlGI4Hb3ZqZ3W0= -github.com/go-git/go-billy/v5 v5.4.0/go.mod h1:vjbugF6Fz7JIflbVpl1hJsGjSHNltrSw45YK/ukIvQg= -github.com/go-git/go-git-fixtures/v4 v4.3.1/go.mod h1:8LHG1a3SRW71ettAD/jW13h8c6AqjVSeL11RAdgaqpo= -github.com/go-git/go-git/v5 v5.5.2/go.mod h1:BE5hUJ5yaV2YMxhmaP4l6RBQ08kMxKSPD4BlxtH7OjI= -github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= -github.com/go-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0= -github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= -github.com/go-logr/logr v0.4.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= -github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.1/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/stdr v1.2.0/go.mod h1:YkVgnZu1ZjjL7xTxrfm/LLZBfkhTqSR1ydtm6jTKKwI= -github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8= -github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= -github.com/go-openapi/jsonreference v0.19.5/go.mod h1:RdybgQwPxbL4UEjuAruzK1x3nE69AqPYEJeo/TWfEeg= -github.com/go-openapi/swag v0.19.14/go.mod h1:QYRuS/SOXUCsnplDa677K7+DxSOj6IPNl/eQntq43wQ= -github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg= -github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= -github.com/go-toolsmith/astcast v1.0.0/go.mod h1:mt2OdQTeAQcY4DQgPSArJjHCcOwlX+Wl/kwN+LbLGQ4= -github.com/go-toolsmith/astcopy v1.0.2/go.mod h1:4TcEdbElGc9twQEYpVo/aieIXfHhiuLh4aLAck6dO7Y= -github.com/go-toolsmith/astequal v1.0.0/go.mod h1:H+xSiq0+LtiDC11+h1G32h7Of5O3CYFJ99GVbS5lDKY= -github.com/go-toolsmith/astequal v1.0.2/go.mod h1:9Ai4UglvtR+4up+bAD4+hCj7iTo4m/OXVTSLnCyTAx4= -github.com/go-toolsmith/astequal v1.0.3/go.mod h1:9Ai4UglvtR+4up+bAD4+hCj7iTo4m/OXVTSLnCyTAx4= -github.com/go-toolsmith/astfmt v1.0.0/go.mod h1:cnWmsOAuq4jJY6Ct5YWlVLmcmLMn1JUPuQIHCY7CJDw= -github.com/go-toolsmith/astp v1.0.0/go.mod h1:RSyrtpVlfTFGDYRbrjyWP1pYu//tSFcvdYrA8meBmLI= -github.com/go-toolsmith/pkgload v1.0.2-0.20220101231613-e814995d17c5/go.mod h1:3NAwwmD4uY/yggRxoEjk/S00MIV3A+H7rrE3i87eYxM= -github.com/go-toolsmith/strparse v1.0.0/go.mod h1:YI2nUKP9YGZnL/L1/DLFBfixrcjslWct4wyljWhSRy8= -github.com/go-toolsmith/typep v1.0.2/go.mod h1:JSQCQMUPdRlMZFswiq3TGpNp1GMktqkR2Ns5AIQkATU= -github.com/go-xmlfmt/xmlfmt v0.0.0-20191208150333-d5b6f63a941b/go.mod h1:aUCEOzzezBEjDBbFBoSiya/gduyIiWYRP6CnSFIV8AM= -github.com/go-zookeeper/zk v1.0.2/go.mod h1:nOB03cncLtlp4t+UAkGSV+9beXP/akpekBwL+UX1Qcw= -github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8= -github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= -github.com/gofrs/uuid v4.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= -github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= -github.com/gogo/status v1.1.0/go.mod h1:BFv9nrluPLmrS0EmGVvLaPNmRosr9KapBYd5/hpY1WM= -github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= -github.com/golang-jwt/jwt/v4 v4.3.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg= -github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= -github.com/golang-sql/sqlexp v0.0.0-20170517235910-f1bb20e5a188/go.mod h1:vXjM/+wXQnTPR4KqTKDgJukSZ6amVRtWMPEjE6sQoK8= -github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= -github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= -github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/golangci/check v0.0.0-20180506172741-cfe4005ccda2/go.mod h1:k9Qvh+8juN+UKMCS/3jFtGICgW8O96FVaZsaxdzDkR4= -github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a/go.mod h1:ryS0uhF+x9jgbj/N71xsEqODy9BN81/GonCZiOzirOk= -github.com/golangci/go-misc v0.0.0-20220329215616-d24fe342adfe/go.mod h1:gjqyPShc/m8pEMpk0a3SeagVb0kaqvhscv+i9jI5ZhQ= -github.com/golangci/gofmt v0.0.0-20220901101216-f2edd75033f2/go.mod h1:9wOXstvyDRshQ9LggQuzBCGysxs3b6Uo/1MvYCR2NMs= -github.com/golangci/golangci-lint v1.50.1/go.mod h1:AQjHBopYS//oB8xs0y0M/dtxdKHkdhl0RvmjUct0/4w= -github.com/golangci/lint-1 v0.0.0-20191013205115-297bf364a8e0/go.mod h1:66R6K6P6VWk9I95jvqGxkqJxVWGFy9XlDwLwVz1RCFg= -github.com/golangci/maligned v0.0.0-20180506175553-b1d89398deca/go.mod h1:tvlJhZqDe4LMs4ZHD0oMUlt9G2LWuDGoisJTBzLMV9o= -github.com/golangci/misspell v0.3.5/go.mod h1:dEbvlSfYbMQDtrpRMQU675gSDLDNa8sCPPChZ7PhiVA= -github.com/golangci/revgrep v0.0.0-20220804021717-745bb2f7c2e6/go.mod h1:0AKcRCkMoKvUvlf89F6O7H2LYdhr1zBh736mBItOdRs= -github.com/golangci/unconvert v0.0.0-20180507085042-28b1c447d1f4/go.mod h1:Izgrg8RkN3rCIMLGE9CyYmU9pY2Jer6DgANEnZ/L/cQ= -github.com/gomodule/redigo v1.7.1-0.20190724094224-574c33c3df38/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4= -github.com/google/btree v1.0.1/go.mod h1:xXMiIv4Fb/0kKde4SpL7qlzvu5cMJDRkFDxJfI9uaxA= -github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck= -github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= -github.com/googleapis/enterprise-certificate-proxy v0.2.1/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= -github.com/googleapis/gax-go/v2 v2.10.0/go.mod h1:4UOEnMCrxsSqQ940WnTiD6qJ63le2ev3xfyagutxiPw= -github.com/googleapis/gnostic v0.5.1/go.mod h1:6U4PtQXGIEt/Z3h5MAT7FNofLnw9vXk2cUuW7uA/OeU= -github.com/googleapis/gnostic v0.5.5/go.mod h1:7+EbHbldMins07ALC74bsA81Ovc97DwqyJO1AENw9kA= -github.com/gordonklaus/ineffassign v0.0.0-20210914165742-4cc7213b9bc8/go.mod h1:Qcp2HIAYhR7mNUVSIxZww3Guk4it82ghYcEXIAk+QT0= -github.com/gostaticanalysis/analysisutil v0.0.0-20190318220348-4088753ea4d3/go.mod h1:eEOZF4jCKGi+aprrirO9e7WKB3beBRtWgqGunKl6pKE= -github.com/gostaticanalysis/analysisutil v0.0.3/go.mod h1:eEOZF4jCKGi+aprrirO9e7WKB3beBRtWgqGunKl6pKE= -github.com/gostaticanalysis/analysisutil v0.1.0/go.mod h1:dMhHRU9KTiDcuLGdy87/2gTR8WruwYZrKdRq9m1O6uw= -github.com/gostaticanalysis/analysisutil v0.7.1/go.mod h1:v21E3hY37WKMGSnbsw2S/ojApNWb6C1//mXO48CXbVc= -github.com/gostaticanalysis/comment v1.3.0/go.mod h1:xMicKDx7XRXYdVwY9f9wQpDJVnqWxw9wCauCMKp+IBI= -github.com/gostaticanalysis/comment v1.4.1/go.mod h1:ih6ZxzTHLdadaiSnF5WY3dxUoXfXAlTaRzuaNDlSado= -github.com/gostaticanalysis/comment v1.4.2/go.mod h1:KLUTGDv6HOCotCH8h2erHKmpci2ZoR8VPu34YA2uzdM= -github.com/gostaticanalysis/forcetypeassert v0.1.0/go.mod h1:qZEedyP/sY1lTGV1uJ3VhWZ2mqag3IkWsDHVbplHXak= -github.com/gostaticanalysis/nilerr v0.1.1/go.mod h1:wZYb6YI5YAxxq0i1+VJbY0s2YONW0HU0GPE3+5PWN4A= -github.com/gostaticanalysis/testutil v0.3.1-0.20210208050101-bfb5c8eec0e4/go.mod h1:D+FIZ+7OahH3ePw/izIEeH5I06eKs1IKI4Xr64/Am3M= -github.com/gostaticanalysis/testutil v0.4.0/go.mod h1:bLIoPefWXrRi/ssLFWX1dx7Repi5x3CuviD3dgAZaBU= -github.com/gotestyourself/gotestyourself v2.2.0+incompatible/go.mod h1:zZKM6oeNM8k+FRljX1mnzVYeS8wiGgQyvST1/GafPbY= -github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3/go.mod h1:o//XUCC/F+yRGJoPO/VU0GSB0f8Nhgmxx0VIRUvaC0w= -github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= -github.com/hashicorp/consul/api v1.18.0/go.mod h1:owRRGJ9M5xReDC5nfT8FTJrNAPbT4NM6p/k+d03q2v4= -github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= -github.com/hashicorp/consul/sdk v0.13.0/go.mod h1:0hs/l5fOVhJy/VdcoaNqUSi2AUs95eF5WKtv+EYIQqE= -github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= -github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ= -github.com/hashicorp/go-hclog v0.12.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= -github.com/hashicorp/go-hclog v1.2.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= -github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= -github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= -github.com/hashicorp/go-retryablehttp v0.7.0/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY= -github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8= -github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A= -github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= -github.com/hashicorp/go-version v1.2.1/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= -github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= -github.com/hashicorp/mdns v1.0.4/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc= -github.com/hashicorp/memberlist v0.5.0/go.mod h1:yvyXLpo0QaGE59Y7hDTsTzDD25JYBZ4mHgHUZ8lrOI0= -github.com/hashicorp/serf v0.10.1/go.mod h1:yL2t6BqATOLGc5HF7qbFkTfXoPIY0WZdWHfEvMqbG+4= -github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= -github.com/hudl/fargo v1.4.0/go.mod h1:9Ai6uvFy5fQNq6VPKtg+Ceq1+eTY4nKUlR2JElEOcDo= -github.com/hydrogen18/memlistener v0.0.0-20141126152155-54553eb933fb/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE= -github.com/hydrogen18/memlistener v0.0.0-20200120041712-dcc25e7acd91/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE= -github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= -github.com/imdario/mergo v0.3.13/go.mod h1:4lJ1jqUDcsbIECGy0RUJAXNIhg+6ocWgb1ALK2O4oXg= -github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA= -github.com/influxdata/influxdb v1.8.3/go.mod h1:JugdFhsvvI8gadxOI6noqNeeBHvWNTbfYGtiAn+2jhI= -github.com/influxdata/influxdb-client-go/v2 v2.4.0/go.mod h1:vLNHdxTJkIf2mSLvGrpj8TCcISApPoXkaxP8g9uRlW8= -github.com/influxdata/influxdb1-client v0.0.0-20200827194710-b269163b24ab/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= -github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= -github.com/informalsystems/tm-load-test v1.3.0/go.mod h1:OQ5AQ9TbT5hKWBNIwsMjn6Bf4O0U4b1kRc+0qZlQJKw= -github.com/intel/goresctrl v0.2.0/go.mod h1:+CZdzouYFn5EsxgqAQTEzMfwKwuc0fVdMrT9FCCAVRQ= -github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI= -github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0= -github.com/iris-contrib/i18n v0.0.0-20171121225848-987a633949d0/go.mod h1:pMCz62A0xJL6I+umB2YTlFRwWXaDFA0jy+5HzGiJjqI= -github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk= -github.com/iris-contrib/pongo2 v0.0.1/go.mod h1:Ssh+00+3GAZqSQb30AvBRNxBx7rf0GqwkjqxNd0u65g= -github.com/iris-contrib/schema v0.0.1/go.mod h1:urYA3uvUNG1TIIjOSCzHr9/LmbQo8LrOcOqfqxa4hXw= -github.com/j-keck/arping v1.0.2/go.mod h1:aJbELhR92bSk7tp79AWM/ftfc90EfEi2bQJrbBFOsPw= -github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= -github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= -github.com/jdxcode/netrc v0.0.0-20210204082910-926c7f70242a/go.mod h1:Zi/ZFkEqFHTm7qkjyNJjaWH4LQA9LQhGJyF0lTYGpxw= -github.com/jedisct1/go-minisign v0.0.0-20190909160543-45766022959e/go.mod h1:G1CVv03EnqU1wYL2dFwXxW2An0az9JTl/ZsqXQeBlkU= -github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4= -github.com/jgautheron/goconst v1.5.1/go.mod h1:aAosetZ5zaeC/2EfMeRswtxUFBpe2Hr7HzkgX4fanO4= -github.com/jhump/gopoet v0.0.0-20190322174617-17282ff210b3/go.mod h1:me9yfT6IJSlOL3FCfrg+L6yzUEZ+5jW6WHt4Sk+UPUI= -github.com/jhump/gopoet v0.1.0/go.mod h1:me9yfT6IJSlOL3FCfrg+L6yzUEZ+5jW6WHt4Sk+UPUI= -github.com/jhump/goprotoc v0.5.0/go.mod h1:VrbvcYrQOrTi3i0Vf+m+oqQWk9l72mjkJCYo7UvLHRQ= -github.com/jhump/protocompile v0.0.0-20220216033700-d705409f108f/go.mod h1:qr2b5kx4HbFS7/g4uYO5qv9ei8303JMsC7ESbYiqr2Q= -github.com/jhump/protoreflect v1.11.0/go.mod h1:U7aMIjN0NWq9swDP7xDdoMfRHb35uiuTd3Z9nFXJf5E= -github.com/jhump/protoreflect v1.12.1-0.20220721211354-060cc04fc18b/go.mod h1:JytZfP5d0r8pVNLZvai7U/MCuTWITgrI4tTg7puQFKI= -github.com/jingyugao/rowserrcheck v1.1.1/go.mod h1:4yvlZSDb3IyDTUZJUmpZfm2Hwok+Dtp+nu2qOq+er9c= -github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af/go.mod h1:HEWGJkRDzjJY2sqdDwxccsGicWEf9BQOZsq2tV+xzM0= -github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks= -github.com/jonboulle/clockwork v0.2.2/go.mod h1:Pkfl5aHPm1nk2H9h0bjmnJD/BcgbGXUBGnn1kMkgxc8= -github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= -github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/juju/errors v0.0.0-20181118221551-089d3ea4e4d5/go.mod h1:W54LbzXuIE0boCoNJfwqpmkKJ1O4TCTZMetAt6jGk7Q= -github.com/juju/loggo v0.0.0-20180524022052-584905176618/go.mod h1:vgyd7OREkbtVEN/8IXZe5Ooef3LQePvuBm9UWj6ZL8U= -github.com/juju/testing v0.0.0-20180920084828-472a3e8b2073/go.mod h1:63prj8cnj0tU0S9OHjGJn+b1h0ZghCndfnbQolrYTwA= -github.com/julz/importas v0.1.0/go.mod h1:oSFU2R4XK/P7kNBrnL/FEQlDGN1/6WoxXEjSSXO0DV0= -github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= -github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k= -github.com/karalabe/usb v0.0.2/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU= -github.com/kataras/golog v0.0.9/go.mod h1:12HJgwBIZFNGL0EJnMRhmvGA0PQGx8VFwrZtM4CqbAk= -github.com/kataras/golog v0.0.10/go.mod h1:yJ8YKCmyL+nWjERB90Qwn+bdyBZsaQwU3bTVFgkFIp8= -github.com/kataras/iris/v12 v12.0.1/go.mod h1:udK4vLQKkdDqMGJJVd/msuMtN6hpYJhg/lSzuxjhO+U= -github.com/kataras/iris/v12 v12.1.8/go.mod h1:LMYy4VlP67TQ3Zgriz8RE2h2kMZV2SgMYbq3UhfoFmE= -github.com/kataras/neffos v0.0.10/go.mod h1:ZYmJC07hQPW67eKuzlfY7SO3bC0mw83A3j6im82hfqw= -github.com/kataras/neffos v0.0.14/go.mod h1:8lqADm8PnbeFfL7CLXh1WHw53dG27MC3pgi2R1rmoTE= -github.com/kataras/pio v0.0.0-20190103105442-ea782b38602d/go.mod h1:NV88laa9UiiDuX9AhMbDPkGYSPugBOV6yTZB1l2K9Z0= -github.com/kataras/pio v0.0.2/go.mod h1:hAoW0t9UmXi4R5Oyq5Z4irTbaTsOemSrDGUtaTl7Dro= -github.com/kataras/sitemap v0.0.5/go.mod h1:KY2eugMKiPwsJgx7+U103YZehfvNGOXURubcGyk0Bz8= -github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= -github.com/kisielk/errcheck v1.6.2/go.mod h1:nXw/i/MfnvRHqXa7XXmQMUB0oNFGuBrNI8d8NLy0LPw= -github.com/kkHAIKE/contextcheck v1.1.3/go.mod h1:PG/cwd6c0705/LM0KTr1acO2gORUxkSVWyLJOFW5qoo= -github.com/klauspost/compress v1.8.2/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= -github.com/klauspost/compress v1.9.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= -github.com/klauspost/compress v1.9.7/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= -github.com/klauspost/cpuid v1.2.1 h1:vJi+O/nMdFt0vqm8NZBI6wzALWdA2X+egi0ogNyrC/w= -github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek= -github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs= -github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= -github.com/kulti/thelper v0.6.3/go.mod h1:DsqKShOvP40epevkFrvIwkCMNYxMeTNjdWL4dqWHZ6I= -github.com/kunwardeep/paralleltest v1.0.6/go.mod h1:Y0Y0XISdZM5IKm3TREQMZ6iteqn1YuwCsJO/0kL9Zes= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/kyoh86/exportloopref v0.1.8/go.mod h1:1tUcJeiioIs7VWe5gcOObrux3lb66+sBqGZrRkMwPgg= -github.com/labstack/echo/v4 v4.1.11/go.mod h1:i541M3Fj6f76NZtHSj7TXnyM8n2gaodfvfxNnFqi74g= -github.com/labstack/echo/v4 v4.5.0/go.mod h1:czIriw4a0C1dFun+ObrXp7ok03xON0N1awStJ6ArI7Y= -github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k= -github.com/ldez/gomoddirectives v0.2.3/go.mod h1:cpgBogWITnCfRq2qGoDkKMEVSaarhdBr6g8G04uz6d0= -github.com/ldez/tagliatelle v0.3.1/go.mod h1:8s6WJQwEYHbKZDsp/LjArytKOG8qaMrKQQ3mFukHs88= -github.com/leonklingele/grouper v1.1.0/go.mod h1:uk3I3uDfi9B6PeUjsCKi6ndcf63Uy7snXgR4yDYQVDY= -github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= -github.com/linxGnu/grocksdb v1.7.10/go.mod h1:0hTf+iA+GOr0jDX4CgIYyJZxqOH9XlBh6KVj8+zmF34= -github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= -github.com/lufeee/execinquery v1.2.1/go.mod h1:EC7DrEKView09ocscGHC+apXMIaorh4xqSxS/dy8SbM= -github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I= -github.com/lyft/protoc-gen-star v0.6.0/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= -github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= -github.com/magiconair/properties v1.8.6/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= -github.com/mailru/easyjson v0.7.6/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= -github.com/maratori/testableexamples v1.0.0/go.mod h1:4rhjL1n20TUTT4vdh3RDqSizKLyXp7K2u6HgraZCGzE= -github.com/maratori/testpackage v1.1.0/go.mod h1:PeAhzU8qkCwdGEMTEupsHJNlQu2gZopMC6RjbhmHeDc= -github.com/matoous/godox v0.0.0-20210227103229-6504466cf951/go.mod h1:1BELzlh859Sh1c6+90blK8lbYy0kwQf1bYlBhBysy1s= -github.com/matryer/is v1.2.0/go.mod h1:2fLPjFQM9rhQ15aVEtbuwhJinnOqrmgXPNdZsdwlWXA= -github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= -github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= -github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= -github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= -github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ= -github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84= -github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= -github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y= -github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= -github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw= -github.com/mbilski/exhaustivestruct v1.2.0/go.mod h1:OeTBVxQWoEmB2J2JCHmXWPJ0aksxSUOUy+nvtVEfzXc= -github.com/mediocregopher/mediocre-go-lib v0.0.0-20181029021733-cb65787f37ed/go.mod h1:dSsfyI2zABAdhcbvkXqgxOxrCsbYeHCPgrZkku60dSg= -github.com/mediocregopher/radix/v3 v3.3.0/go.mod h1:EmfVyvspXz1uZEyPBMyGK+kjWiKQGvsUt6O3Pj+LDCQ= -github.com/mediocregopher/radix/v3 v3.4.2/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8= -github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517/go.mod h1:KQ7+USdGKfpPjXk4Ga+5XxQM4Lm4e3gAogrreFAYpOg= -github.com/mgechev/revive v1.2.4/go.mod h1:iAWlQishqCuj4yhV24FTnKSXGpbAA+0SckXB8GQMX/Q= -github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc= -github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso= -github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI= -github.com/miekg/pkcs11 v1.1.1/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs= -github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g= -github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ= -github.com/mistifyio/go-zfs v2.1.2-0.20190413222219-f784269be439+incompatible/go.mod h1:8AuVvqP/mXw1px98n46wfvcGfQ4ci2FwoAjKYxuo3Z4= -github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI= -github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg= -github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo= -github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= -github.com/moby/buildkit v0.10.4/go.mod h1:Yajz9vt1Zw5q9Pp4pdb3TCSUXJBIroIQGQ3TTs/sLug= -github.com/moby/locker v1.0.1/go.mod h1:S7SDdo5zpBK84bzzVlKr2V0hz+7x9hWbYC/kq7oQppc= -github.com/moby/spdystream v0.2.0/go.mod h1:f7i0iNDQJ059oMTcWxx8MA/zKFIuD/lY+0GqbN2Wy8c= -github.com/moby/sys/signal v0.6.0/go.mod h1:GQ6ObYZfqacOwTtlXvcmh9A26dVRul/hbOZn88Kg8Tg= -github.com/moby/sys/symlink v0.2.0/go.mod h1:7uZVF2dqJjG/NsClqul95CqKOBRQyYSNnJ6BMgR/gFs= -github.com/moby/term v0.0.0-20210610120745-9d4ed1856297/go.mod h1:vgPCkQMyxTZ7IDy8SXRufE172gr8+K/JE/7hHFxHW3A= -github.com/moricho/tparallel v0.2.1/go.mod h1:fXEIZxG2vdfl0ZF8b42f5a78EhjjD5mX8qUplsoSU4k= -github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ= -github.com/mozilla/tls-observatory v0.0.0-20210609171429-7bc42856d2e5/go.mod h1:FUqVoUPHSEdDR0MnFM3Dh8AU0pZHLXUD127SAJGER/s= -github.com/nakabonne/nestif v0.3.1/go.mod h1:9EtoZochLn5iUprVDmDjqGKPofoUEBL8U4Ngq6aY7OE= -github.com/naoina/go-stringutil v0.1.0/go.mod h1:XJ2SJL9jCtBh+P9q5btrd/Ylo8XwT/h1USek5+NqSA0= -github.com/naoina/toml v0.1.2-0.20170918210437-9fafd6967416/go.mod h1:NBIhNtsFMo3G2szEBne+bO4gS192HuIYRqfvOWb4i1E= -github.com/nats-io/jwt/v2 v2.0.3/go.mod h1:VRP+deawSXyhNjXmxPCHskrR6Mq50BqpEI5SEcNiGlY= -github.com/nats-io/nats-server/v2 v2.5.0/go.mod h1:Kj86UtrXAL6LwYRA6H4RqzkHhK0Vcv2ZnKD5WbQ1t3g= -github.com/nats-io/nats.go v1.8.1/go.mod h1:BrFz9vVn0fU3AcH9Vn4Kd7W0NpJ651tD5omQ3M8LwxM= -github.com/nats-io/nats.go v1.12.1/go.mod h1:BPko4oXsySz4aSWeFgOHLZs3G4Jq4ZAyE6/zMCxRT6w= -github.com/nats-io/nkeys v0.0.2/go.mod h1:dab7URMsZm6Z/jp9Z5UGa87Uutgc2mVpXLC4B7TDb/4= -github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4= -github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354/go.mod h1:KSVJerMDfblTH7p5MZaTt+8zaT2iEk3AkVb9PQdZuE8= -github.com/nishanths/exhaustive v0.8.3/go.mod h1:qj+zJJUgJ76tR92+25+03oYUhzF4R7/2Wk7fGTfCHmg= -github.com/nishanths/predeclared v0.2.2/go.mod h1:RROzoN6TnGQupbC+lqggsOlcgysk3LMK/HI84Mp280c= -github.com/onsi/ginkgo v1.13.0/go.mod h1:+REjRxOmWfHCjfv9TTWB1jD1Frx4XydAD3zm1lskyM0= -github.com/onsi/ginkgo/v2 v2.1.4/go.mod h1:um6tUpWM/cxCK3/FK8BXqEiUMUwRgSM4JXG47RKZmLU= -github.com/onsi/gomega v1.15.0/go.mod h1:cIuvLEne0aoVhAgh/O6ac0Op8WWw9H6eYCriF+tEHG0= -github.com/opencontainers/image-spec v1.0.2-0.20211117181255-693428a734f5/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0= -github.com/opencontainers/image-spec v1.0.2/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0= -github.com/opencontainers/image-spec v1.0.3-0.20211202183452-c5a74bcca799/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0= -github.com/opencontainers/runc v1.1.0/go.mod h1:Tj1hFw6eFWp/o33uxGf5yF2BX5yz2Z6iptFpuvbbKqc= -github.com/opencontainers/runc v1.1.2/go.mod h1:Tj1hFw6eFWp/o33uxGf5yF2BX5yz2Z6iptFpuvbbKqc= -github.com/opencontainers/selinux v1.10.1/go.mod h1:2i0OySw99QjzBBQByd1Gr9gSjvuho1lHsJxIJ3gGbJI= -github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= -github.com/openzipkin/zipkin-go v0.2.5/go.mod h1:KpXfKdgRDnnhsxw4pNIH9Md5lyFqKUa4YDFlwRYAMyE= -github.com/ory/dockertest/v3 v3.9.1/go.mod h1:42Ir9hmvaAPm0Mgibk6mBPi7SFvTXxEcnztDYOJ//uM= -github.com/otiai10/copy v1.2.0/go.mod h1:rrF5dJ5F0t/EWSYODDu4j9/vEeYHMkc8jt0zJChqQWw= -github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE= -github.com/otiai10/curr v1.0.0/go.mod h1:LskTG5wDwr8Rs+nNQ+1LlxRjAtTZZjtJW4rMXl6j4vs= -github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo= -github.com/otiai10/mint v1.3.1/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc= -github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= -github.com/pelletier/go-toml/v2 v2.0.5/go.mod h1:OMHamSCAODeSsVrwwvcJOaoN0LIUIaFVNZzmWyNfXas= -github.com/performancecopilot/speed/v4 v4.0.0/go.mod h1:qxrSyuDGrTOWfV+uKRFhfxw6h/4HXRGUiZiufxo49BM= -github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= -github.com/phayes/checkstyle v0.0.0-20170904204023-bfd46e6a821d/go.mod h1:3OzsM7FXDQlpCiw2j81fOmAwQLnZnLGXVKUzeKQXIAw= -github.com/pjbgf/sha1cd v0.2.3/go.mod h1:HOK9QrgzdHpbc2Kzip0Q1yi3M2MFGPADtR6HjG65m5M= -github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI= -github.com/pkg/profile v1.6.0/go.mod h1:qBsxPvzyUincmltOk6iyRVxHYg4adc0OFOv72ZdLa18= -github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= -github.com/pointlander/compress v1.1.1-0.20190518213731-ff44bd196cc3/go.mod h1:q5NXNGzqj5uPnVuhGkZfmgHqNUhf15VLi6L9kW0VEc0= -github.com/pointlander/jetset v1.0.1-0.20190518214125-eee7eff80bd4/go.mod h1:RdR1j20Aj5pB6+fw6Y9Ur7lMHpegTEjY1vc19hEZL40= -github.com/pointlander/peg v1.0.1/go.mod h1:5hsGDQR2oZI4QoWz0/Kdg3VSVEC31iJw/b7WjqCBGRI= -github.com/polyfloyd/go-errorlint v1.0.5/go.mod h1:APVvOesVSAnne5SClsPxPdfvZTVDojXh1/G3qb5wjGI= -github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s= -github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= -github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0= -github.com/prometheus/client_golang v1.11.1/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0= -github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= -github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= -github.com/prometheus/common v0.30.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= -github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= -github.com/prometheus/common v0.37.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA= -github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= -github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4= -github.com/quasilyte/go-ruleguard v0.3.1-0.20210203134552-1b5a410e1cc8/go.mod h1:KsAh3x0e7Fkpgs+Q9pNLS5XpFSvYCEVl5gP9Pp1xp30= -github.com/quasilyte/go-ruleguard v0.3.18/go.mod h1:lOIzcYlgxrQ2sGJ735EHXmf/e9MJ516j16K/Ifcttvs= -github.com/quasilyte/go-ruleguard/dsl v0.3.0/go.mod h1:KeCP03KrjuSO0H1kTuZQCWlQPulDV6YMIXmpQss17rU= -github.com/quasilyte/go-ruleguard/dsl v0.3.21/go.mod h1:KeCP03KrjuSO0H1kTuZQCWlQPulDV6YMIXmpQss17rU= -github.com/quasilyte/go-ruleguard/rules v0.0.0-20201231183845-9e62ed36efe1/go.mod h1:7JTjp89EGyU1d6XfBiXihJNG37wB2VRkd125Q1u7Plc= -github.com/quasilyte/go-ruleguard/rules v0.0.0-20211022131956-028d6511ab71/go.mod h1:4cgAphtvu7Ftv7vOT2ZOYhC6CvBxZixcasr8qIOTA50= -github.com/quasilyte/gogrep v0.0.0-20220828223005-86e4605de09f/go.mod h1:Cm9lpz9NZjEoL1tgZ2OgeUKPIxL1meE7eo60Z6Sk+Ng= -github.com/quasilyte/regex/syntax v0.0.0-20200407221936-30656e2c4a95/go.mod h1:rlzQ04UMyJXu/aOvhd8qT+hvDrFpiwqp8MRXDY9szc0= -github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567/go.mod h1:DWNGW8A4Y+GyBgPuaQJuWiy0XYftx4Xm/y5Jqk9I6VQ= -github.com/remyoudompheng/go-dbus v0.0.0-20121104212943-b7232d34b1d5/go.mod h1:+u151txRmLpwxBmpYn9z3d1sdJdjRPQpsXuYeY9jNls= -github.com/remyoudompheng/go-liblzma v0.0.0-20190506200333-81bf2d431b96/go.mod h1:90HvCY7+oHHUKkbeMCiHt1WuFR2/hPJ9QrljDG+v6ls= -github.com/remyoudompheng/go-misc v0.0.0-20190427085024-2d6ac652a50e/go.mod h1:80FQABjoFzZ2M5uEa6FUaJYEmqU2UOKojlFVak1UAwI= -github.com/rivo/tview v0.0.0-20220307222120-9994674d60a8/go.mod h1:WIfMkQNY+oq/mWwtsjOYHIZBuwthioY2srOmljJkTnk= -github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho= -github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= -github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o= -github.com/rs/cors v1.8.2/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= -github.com/rs/xid v1.3.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= -github.com/rs/zerolog v1.27.0 h1:1T7qCieN22GVc8S4Q2yuexzBb1EqjbgjSH9RohbMjKs= -github.com/rs/zerolog v1.27.0/go.mod h1:7frBqO0oezxmnO7GF86FY++uy8I0Tk/If5ni1G9Qc0U= -github.com/russross/blackfriday v1.6.0/go.mod h1:ti0ldHuxg49ri4ksnFxlkCfN+hvslNlmVHqNRXXJNAY= -github.com/ryancurrah/gomodguard v1.2.4/go.mod h1:+Kem4VjWwvFpUJRJSwa16s1tBJe+vbv02+naTow2f6M= -github.com/ryanrolds/sqlclosecheck v0.3.0/go.mod h1:1gREqxyTGR3lVtpngyFo3hZAgk0KCtEdgEkHwDbigdA= -github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= -github.com/safchain/ethtool v0.0.0-20210803160452-9aa261dae9b1/go.mod h1:Z0q5wiBQGYcxhMZ6gUqHn6pYNLypFAvaL3UvgZLR0U4= -github.com/sagikazarmark/crypt v0.9.0/go.mod h1:RnH7sEhxfdnPm1z+XMgSLjWTEIjyK4z2dw6+4vHTMuo= -github.com/sanposhiho/wastedassign/v2 v2.0.6/go.mod h1:KyZ0MWTwxxBmfwn33zh3k1dmsbF2ud9pAAGfoLfjhtI= -github.com/sashamelentyev/interfacebloat v1.1.0/go.mod h1:+Y9yU5YdTkrNvoX0xHc84dxiN1iBi9+G8zZIhPVoNjQ= -github.com/sashamelentyev/usestdlibvars v1.20.0/go.mod h1:0GaP+ecfZMXShS0A94CJn6aEuPRILv8h/VuWI9n1ygg= -github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0= -github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g= -github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw= -github.com/seccomp/libseccomp-golang v0.9.2-0.20210429002308-3879420cc921/go.mod h1:JA8cRccbGaA1s33RQf7Y1+q9gHmZX1yB/z9WDN1C6fg= -github.com/securego/gosec/v2 v2.13.1/go.mod h1:EO1sImBMBWFjOTFzMWfTRrZW6M15gm60ljzrmy/wtHo= -github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= -github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= -github.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c/go.mod h1:/PevMnwAxekIXwN8qQyfc5gl2NlkB3CQlkizAbOkeBs= -github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk= -github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ= -github.com/sivchari/containedctx v1.0.2/go.mod h1:PwZOeqm4/DLoJOqMSIJs3aKqXRX4YO+uXww087KZ7Bw= -github.com/sivchari/nosnakecase v1.7.0/go.mod h1:CwDzrzPea40/GB6uynrNLiorAlgFRvRbFSgJx2Gs+QY= -github.com/sivchari/tenv v1.7.0/go.mod h1:64yStXKSOxDfX47NlhVwND4dHwfZDdbp2Lyl018Icvg= -github.com/skeema/knownhosts v1.1.0/go.mod h1:sKFq3RD6/TKZkSWn8boUbDC7Qkgcv+8XXijpFO6roag= -github.com/snikch/goodman v0.0.0-20171125024755-10e37e294daa/go.mod h1:oJyF+mSPHbB5mVY2iO9KV3pTt/QbIkGaO8gQ2WrDbP4= -github.com/soheilhy/cmux v0.1.5/go.mod h1:T7TcVDs9LWfQgPlPsdngu6I6QIoyIFZDDC6sNE1GqG0= -github.com/sonatard/noctx v0.0.1/go.mod h1:9D2D/EoULe8Yy2joDHJj7bv3sZoq9AaSb8B4lqBjiZI= -github.com/sourcegraph/go-diff v0.6.1/go.mod h1:iBszgVvyxdc8SFZ7gm69go2KDdt3ag071iBaWPF6cjs= -github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= -github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= -github.com/spf13/afero v1.8.2/go.mod h1:CtAatgMJh6bJEIs48Ay/FOnkljP3WeGUG0MC1RfAqwo= -github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y= -github.com/spf13/cobra v1.1.3/go.mod h1:pGADOWyqRD/YMrPZigI/zbliZ2wVD/23d+is3pSWzOo= -github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= -github.com/spf13/viper v1.13.0/go.mod h1:Icm2xNL3/8uyh/wFuB1jI7TiTNKp8632Nwegu+zgdYw= -github.com/spf13/viper v1.14.0/go.mod h1:WT//axPky3FdvXHzGw33dNdXXXfFQqmEalje+egj8As= -github.com/ssgreg/nlreturn/v2 v2.2.1/go.mod h1:E/iiPB78hV7Szg2YfRgyIrk1AD6JVMTRkkxBiELzh2I= -github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q= -github.com/stbenjam/no-sprintf-host-port v0.1.1/go.mod h1:TLhvtIvONRzdmkFiio4O8LHsN9N74I+PhRquPsxpL0I= -github.com/stefanberger/go-pkcs11uri v0.0.0-20201008174630-78d3cae3a980/go.mod h1:AO3tvPzVZ/ayst6UlUKUv6rcPQInYe3IknH3jYhAKu8= -github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= -github.com/streadway/amqp v1.0.0/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= -github.com/streadway/handy v0.0.0-20200128134331-0f66f006fb2e/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= -github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= -github.com/stretchr/testify v1.1.4/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= -github.com/stretchr/testify v1.7.5/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= -github.com/subosito/gotenv v1.4.1/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0= -github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca/go.mod h1:u2MKkTVTVJWe5D1rCvame8WqhBd88EuIwODJZ1VHCPM= -github.com/tchap/go-patricia v2.2.6+incompatible/go.mod h1:bmLyhP68RS6kStMGxByiQ23RP/odRBOTVjwp2cDyi6I= -github.com/tdakkota/asciicheck v0.1.1/go.mod h1:yHp0ai0Z9gUljN3o0xMhYJnH/IcvkdTBOX2fmJ93JEM= -github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c/go.mod h1:ahpPrc7HpcfEWDQRZEmnXMzHY03mLDYMCxeDzy46i+8= -github.com/tendermint/tendermint v0.37.0-rc2/go.mod h1:uYQO9DRNPeZROa9X3hJOZpYcVREDC2/HST+EiU5g2+A= -github.com/tendermint/tm-db v0.6.7/go.mod h1:byQDzFkZV1syXr/ReXS808NxA2xvyuuVgXOJ/088L6I= -github.com/tenntenn/modver v1.0.1/go.mod h1:bePIyQPb7UeioSRkw3Q0XeMhYZSMx9B8ePqg6SAMGH0= -github.com/tenntenn/text/transform v0.0.0-20200319021203-7eef512accb3/go.mod h1:ON8b8w4BN/kE1EOhwT0o+d62W65a6aPw1nouo9LMgyY= -github.com/tetafro/godot v1.4.11/go.mod h1:LR3CJpxDVGlYOWn3ZZg1PgNZdTUvzsZWu8xaEohUpn8= -github.com/timakin/bodyclose v0.0.0-20210704033933-f49887972144/go.mod h1:Qimiffbc6q9tBWlVV6x0P9sat/ao1xEkREYPPj9hphk= -github.com/timonwong/loggercheck v0.9.3/go.mod h1:wUqnk9yAOIKtGA39l1KLE9Iz0QiTocu/YZoOf+OzFdw= -github.com/tmc/grpc-websocket-proxy v0.0.0-20201229170055-e5319fda7802/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= -github.com/tomarrell/wrapcheck/v2 v2.7.0/go.mod h1:ao7l5p0aOlUNJKI0qVwB4Yjlqutd0IvAB9Rdwyilxvg= -github.com/tommy-muehle/go-mnd/v2 v2.5.1/go.mod h1:WsUAkMJMYww6l/ufffCD3m+P7LEvr8TnZn9lwVDlgzw= -github.com/tv42/httpunix v0.0.0-20191220191345-2ba4b9c3382c/go.mod h1:hzIxponao9Kjc7aWznkXaL4U4TWaDSs8zcsY4Ka08nM= -github.com/ultraware/funlen v0.0.3/go.mod h1:Dp4UiAus7Wdb9KUZsYWZEWiRzGuM2kXM1lPbfaF6xhA= -github.com/ultraware/whitespace v0.0.5/go.mod h1:aVMh/gQve5Maj9hQ/hg+F75lr/X5A89uZnzAmWSineA= -github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= -github.com/urfave/cli v1.22.4/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= -github.com/urfave/negroni v1.0.0/go.mod h1:Meg73S6kFm/4PpbYdq35yYWoCZ9mS/YSx+lKnmiohz4= -github.com/uudashr/gocognit v1.0.6/go.mod h1:nAIUuVBnYU7pcninia3BHOvQkpQCeO76Uscky5BOwcY= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBnvPM1Su9w= -github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8= -github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= -github.com/valyala/quicktemplate v1.7.0/go.mod h1:sqKJnoaOF88V07vkO+9FL8fb9uZg/VPSJnLYn+LmLk8= -github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio= -github.com/vektra/mockery/v2 v2.14.0/go.mod h1:bnD1T8tExSgPD1ripLkDbr60JA9VtQeu12P3wgLZd7M= -github.com/vishvananda/netlink v1.1.1-0.20210330154013-f5de75959ad5/go.mod h1:twkDnbuQxJYemMlGd4JFIcuhgX83tXhKS2B/PRMpOho= -github.com/vishvananda/netns v0.0.0-20210104183010-2eb08e3e575f/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0= -github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc= -github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds= -github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= -github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= -github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= -github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= -github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= -github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs= -github.com/yagipy/maintidx v1.0.0/go.mod h1:0qNf/I/CCZXSMhsRsrEPDZ+DkekpKLXAJfsTACwgXLk= -github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI= -github.com/yeya24/promlinter v0.2.0/go.mod h1:u54lkmBOZrpEbQQ6gox2zWKKLKu2SGe+2KOiextY+IA= -github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg= -github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM= -github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc= -github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= -github.com/zondax/ledger-go v0.14.0/go.mod h1:fZ3Dqg6qcdXWSOJFKMG8GCTnD7slO/RL2feOQv8K320= -gitlab.com/bosi/decorder v0.2.3/go.mod h1:9K1RB5+VPNQYtXtTDAzd2OEftsZb1oV0IrJrzChSdGE= -go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= -go.etcd.io/etcd/api/v3 v3.5.6/go.mod h1:KFtNaxGDw4Yx/BA4iPPwevUTAuqcsPxzyX8PHydchN8= -go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= -go.etcd.io/etcd/client/pkg/v3 v3.5.6/go.mod h1:ggrwbk069qxpKPq8/FKkQ3Xq9y39kbFR4LnKszpRXeQ= -go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ= -go.etcd.io/etcd/client/v2 v2.305.6/go.mod h1:BHha8XJGe8vCIBfWBpbBLVZ4QjOIlfoouvOwydu63E0= -go.etcd.io/etcd/client/v3 v3.5.0/go.mod h1:AIKXXVX/DQXtfTEqBryiLTUXwON+GuvO6Z7lLS/oTh0= -go.etcd.io/etcd/client/v3 v3.5.6/go.mod h1:f6GRinRMCsFVv9Ht42EyY7nfsVGwrNO0WEoS2pRKzQk= -go.etcd.io/etcd/pkg/v3 v3.5.0/go.mod h1:UzJGatBQ1lXChBkQF0AuAtkRQMYnHubxAEYIrC3MSsE= -go.etcd.io/etcd/raft/v3 v3.5.0/go.mod h1:UFOHSIvO/nKwd4lhkwabrTD3cqW5yVyYYf/KlD00Szc= -go.etcd.io/etcd/server/v3 v3.5.0/go.mod h1:3Ah5ruV+M+7RZr0+Y/5mNLwC+eQlni+mQmOVdCRJoS4= -go.etcd.io/gofail v0.1.0/go.mod h1:VZBCXYGZhHAinaBiiqYvuDynvahNsAyLFwB3kEHKz1M= -go.mozilla.org/pkcs7 v0.0.0-20200128120323-432b2356ecb1/go.mod h1:SNgMg+EgDFwmvSmLRTNKC5fegJjB7v23qTQ0XLGUNHk= -go.opentelemetry.io/contrib v0.20.0/go.mod h1:G/EtFaa6qaN7+LxqfIAT3GiZa7Wv5DTBUzl5H4LY0Kc= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.20.0/go.mod h1:oVGt1LRbBOBq1A5BQLlUg9UaU/54aiHw8cgjV3aWZ/E= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.28.0/go.mod h1:vEhqr0m4eTc+DWxfsXoXue2GBgV2uUwVznkGIHW/e5w= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.36.3/go.mod h1:Dts42MGkzZne2yCru741+bFiTMWkIj/LLRizad7b9tw= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.20.0/go.mod h1:2AboqHi0CiIZU0qwhtUfCYD1GeUzvvIXWNkhDt7ZMG4= -go.opentelemetry.io/otel v0.20.0/go.mod h1:Y3ugLH2oa81t5QO+Lty+zXf8zC9L26ax4Nzoxm/dooo= -go.opentelemetry.io/otel v1.3.0/go.mod h1:PWIKzi6JCp7sM0k9yZ43VX+T345uNbAkDKwHVjb2PTs= -go.opentelemetry.io/otel v1.4.1/go.mod h1:StM6F/0fSwpd8dKWDCdRr7uRvEPYdW0hBSlbdTiUde4= -go.opentelemetry.io/otel v1.11.0/go.mod h1:H2KtuEphyMvlhZ+F7tg9GRhAOe60moNx61Ex+WmiKkk= -go.opentelemetry.io/otel/exporters/otlp v0.20.0/go.mod h1:YIieizyaN77rtLJra0buKiNBOm9XQfkPEKBeuhoMwAM= -go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.3.0/go.mod h1:VpP4/RMn8bv8gNo9uK7/IMY4mtWLELsS+JIP0inH0h4= -go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.4.1/go.mod h1:VpP4/RMn8bv8gNo9uK7/IMY4mtWLELsS+JIP0inH0h4= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.3.0/go.mod h1:hO1KLR7jcKaDDKDkvI9dP/FIhpmna5lkqPUQdEjFAM8= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.4.1/go.mod h1:o5RW5o2pKpJLD5dNTCmjF1DorYwMeFJmb/rKr5sLaa8= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.3.0/go.mod h1:keUU7UfnwWTWpJ+FWnyqmogPa82nuU5VUANFq49hlMY= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.4.1/go.mod h1:c6E4V3/U+miqjs/8l950wggHGL1qzlp0Ypj9xoGrPqo= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.3.0/go.mod h1:QNX1aly8ehqqX1LEa6YniTU7VY9I6R3X/oPxhGdTceE= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.4.1/go.mod h1:VwYo0Hak6Efuy0TXsZs8o1hnV3dHDPNtDbycG0hI8+M= -go.opentelemetry.io/otel/metric v0.20.0/go.mod h1:598I5tYlH1vzBjn+BTuhzTCSb/9debfNp6R3s7Pr1eU= -go.opentelemetry.io/otel/oteltest v0.20.0/go.mod h1:L7bgKf9ZB7qCwT9Up7i9/pn0PWIa9FqQ2IQ8LoxiGnw= -go.opentelemetry.io/otel/sdk v0.20.0/go.mod h1:g/IcepuwNsoiX5Byy2nNV0ySUF1em498m7hBWC279Yc= -go.opentelemetry.io/otel/sdk v1.3.0/go.mod h1:rIo4suHNhQwBIPg9axF8V9CA72Wz2mKF1teNrup8yzs= -go.opentelemetry.io/otel/sdk v1.4.1/go.mod h1:NBwHDgDIBYjwK2WNu1OPgsIc2IJzmBXNnvIJxJc8BpE= -go.opentelemetry.io/otel/sdk/export/metric v0.20.0/go.mod h1:h7RBNMsDJ5pmI1zExLi+bJK+Dr8NQCh0qGhm1KDnNlE= -go.opentelemetry.io/otel/sdk/metric v0.20.0/go.mod h1:knxiS8Xd4E/N+ZqKmUPf3gTTZ4/0TjTXukfxjzSTpHE= -go.opentelemetry.io/otel/trace v0.20.0/go.mod h1:6GjCW8zgDjwGHGa6GkyeB8+/5vjT16gUEi0Nf1iBdgw= -go.opentelemetry.io/otel/trace v1.3.0/go.mod h1:c/VDhno8888bvQYmbYLqe41/Ldmr/KKunbvWM4/fEjk= -go.opentelemetry.io/otel/trace v1.4.1/go.mod h1:iYEVbroFCNut9QkwEczV9vMRPHNKSSwYZjulEtsmhFc= -go.opentelemetry.io/otel/trace v1.11.0/go.mod h1:nyYjis9jy0gytE9LXGU+/m1sHTKbRY0fX0hulNNDP1U= -go.opentelemetry.io/proto/otlp v0.11.0/go.mod h1:QpEjXPrNQzrFDZgoTo49dgHR9RYRSrg3NAKnUGl9YpQ= -go.opentelemetry.io/proto/otlp v0.12.0/go.mod h1:TsIjwGWIx5VFYv9KGVlOpxoBl5Dy+63SUguV7GGvlSQ= -go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= -go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= -go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= -go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= -go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= -go.uber.org/zap v1.23.0/go.mod h1:D+nX8jyLsMHMYrln8A0rJjFt/T/9/bGgIhAqxv5URuY= -golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY= -golang.org/x/crypto v0.0.0-20191227163750-53104e6ec876/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20220315160706-3147a52a75dd/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.0.0-20220826181053-bd7e27e6170d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.3.0/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4= -golang.org/x/crypto v0.5.0/go.mod h1:NK/OQwhpMQP3MwtdjgLlYHnH9ebylxKWv3e0fK+mkQU= -golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0= -golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20200513190911-00229845015e/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= -golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e/go.mod h1:Kr81I6Kryrl9sr8s2FK3vxD90NdsKWRuOIl2O4CvYbA= -golang.org/x/exp v0.0.0-20221019170559-20944726eadf/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= -golang.org/x/exp v0.0.0-20221205204356-47842c84f3db/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= -golang.org/x/exp v0.0.0-20230131160201-f062dba9d201/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= -golang.org/x/exp/typeparams v0.0.0-20220428152302-39d4317da171/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= -golang.org/x/exp/typeparams v0.0.0-20220827204233-334a2380cb91/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= -golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= -golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= -golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= -golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY= -golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI= -golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/net v0.0.0-20190327091125-710a502c58a2/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8= -golang.org/x/net v0.0.0-20210520170846-37e1c6afe023/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211209124913-491a49abca63/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211216030914-fe4d6282115f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= -golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= -golang.org/x/net v0.4.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE= -golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= -golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= -golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= -golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= -golang.org/x/oauth2 v0.3.0/go.mod h1:rQrIauxkUhJ6CuwEXwymO2/eh4xz2ZWF1nBkcxS+tGk= -golang.org/x/oauth2 v0.4.0/go.mod h1:RznEsdpjGAINPTOF0UH/t+xJ75L18YO3Ho6Pyn+uRec= -golang.org/x/oauth2 v0.5.0/go.mod h1:9/XBHVqLaWO3/BRHs5jbpYCnOZVjj5V0ndyaAM7KB4I= -golang.org/x/oauth2 v0.7.0/go.mod h1:hPLQkd9LyjfXTiRohC/41GhcFqxisoUQ99sCUOHO9x4= -golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200831180312-196b9ba8737a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210616045830-e2b7044e8c71/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210831042530-f4d43177bf5e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210903071746-97244b99971b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210909193231-528a39cd75f3/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211105183446-c75c47738b0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220422013727-9388b58f7150/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220702020025-31831981b65f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= -golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.0.0-20220722155259-a9ba230a4035/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= -golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA= -golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= -golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= -golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20181221001348-537d06c36207/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190307163923-6a08e3108db3/go.mod h1:25r3+/G6/xytQM8iWZKq3Hn0kr0rgFKPUNVEL/dr3z4= -golang.org/x/tools v0.0.0-20190311215038-5c2858a9cfe5/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190321232350-e250d351ecad/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190322203728-c1a832b0ad89/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190327201419-c70d86f8b7cf/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20190910044552-dd2b5c81c578/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20190916130336-e45ffcd953cc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20200117220505-0cba7a3a9ee9/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200324003944-a576cf524670/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= -golang.org/x/tools v0.0.0-20200329025819-fd4102a86c65/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= -golang.org/x/tools v0.0.0-20200414032229-332987a829c3/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200622203043-20e05c1c8ffa/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200624225443-88f3c62a19ff/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200625211823-6506e20df31f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200724022722-7017fd6b1305/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200812195022-5ae4c3c160a0/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200820010801-b793a1359eac/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200831203904-5a2aa26beb65/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= -golang.org/x/tools v0.0.0-20201001104356-43ebab892c4c/go.mod h1:z6u4i615ZeAfBE4XtMziQW1fSVJXACjjbWkB/mvPzlU= -golang.org/x/tools v0.0.0-20201002184944-ecd9fd270d5d/go.mod h1:z6u4i615ZeAfBE4XtMziQW1fSVJXACjjbWkB/mvPzlU= -golang.org/x/tools v0.0.0-20201023174141-c8cfbd0f21e6/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20201230224404-63754364767c/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.1-0.20210205202024-ef80cdb6ec6d/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU= -golang.org/x/tools v0.1.1-0.20210302220138-2ac05c832e1a/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU= -golang.org/x/tools v0.1.9-0.20211228192929-ee1ca4ffc4da/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= -golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= -golang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E= -golang.org/x/tools v0.1.11/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4= -golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA= -gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= -gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0= -gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= -gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc= -google.golang.org/api v0.106.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= -google.golang.org/api v0.107.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= -google.golang.org/api v0.108.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= -google.golang.org/api v0.125.0/go.mod h1:mBwVAtz+87bEN6CbA1GtZPDOqY2R5ONPqJeIlvyo4Aw= -google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= -google.golang.org/genproto v0.0.0-20201019141844-1ed22bb0c154/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20220329172620-7be39ac1afc7/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= -google.golang.org/genproto v0.0.0-20221118155620-16455021b5e6/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= -google.golang.org/genproto v0.0.0-20221227171554-f9683d7f8bef/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= -google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= -google.golang.org/genproto v0.0.0-20230124163310-31e0e69b6fc2/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= -google.golang.org/genproto v0.0.0-20230125152338-dcaf20b6aeaa/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= -google.golang.org/genproto v0.0.0-20230202175211-008b39050e57/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= -google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= -google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1/go.mod h1:nKE/iIaLqn2bQwXBg8f1g2Ylh6r5MN5CmZvuzZCgsCU= -google.golang.org/genproto v0.0.0-20230525234025-438c736192d0/go.mod h1:9ExIQyXL5hZrHzQceCwuSYwZZ5QZBazOcprJ5rgs3lY= -google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:xZnkP7mREFX5MORlOPEzLMr+90PPZQ2QWzrVTWfAq64= -google.golang.org/genproto/googleapis/api v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= -google.golang.org/genproto/googleapis/bytestream v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:ylj+BE99M198VPbBh6A8d9n3w8fChvyLK3wwBOjXBFA= -google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234030-28d5490b6b19/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= -google.golang.org/genproto/googleapis/rpc v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= -google.golang.org/genproto/googleapis/rpc v0.0.0-20230629202037-9506855d4529/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= -google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= -google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k= -google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= -google.golang.org/grpc v1.43.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= -google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww= -google.golang.org/grpc v1.52.0/go.mod h1:pu6fVzoFb+NBYNAvQL08ic+lvB2IojljRYuun5vorUY= -google.golang.org/grpc v1.52.3/go.mod h1:pu6fVzoFb+NBYNAvQL08ic+lvB2IojljRYuun5vorUY= -google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw= -google.golang.org/grpc v1.54.0/go.mod h1:PUSEXI6iWghWaB6lXM4knEgpJNu2qUcKfDtNci3EC2g= -google.golang.org/grpc v1.55.0/go.mod h1:iYEXKGkEBhg1PjZQvoYEVPTDkHo1/bjTnfwTeGONTY8= -google.golang.org/protobuf v1.27.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.28.2-0.20220831092852-f930b1dc76e8/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= -google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= -gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE= -gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y= -gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= -gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/ini.v1 v1.51.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA= -gopkg.in/square/go-jose.v2 v2.5.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI= -gopkg.in/yaml.v3 v3.0.0-20191120175047-4206685974f2/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= -gotest.tools/v3 v3.2.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= -gotest.tools/v3 v3.4.0/go.mod h1:CtbdzLSsqVhDgMtKsx03ird5YTGB3ar27v0u/yKBW5g= -honnef.co/go/tools v0.3.3/go.mod h1:jzwdWgg7Jdq75wlfblQxO4neNaFFSvgc1tD5Wv8U0Yw= -k8s.io/api v0.22.5/go.mod h1:mEhXyLaSD1qTOf40rRiKXkc+2iCem09rWLlFwhCEiAs= -k8s.io/apimachinery v0.22.1/go.mod h1:O3oNtNadZdeOMxHFVxOreoznohCpy0z6mocxbZr7oJ0= -k8s.io/apimachinery v0.22.5/go.mod h1:xziclGKwuuJ2RM5/rSFQSYAj0zdbci3DH8kj+WvyN0U= -k8s.io/apiserver v0.22.5/go.mod h1:s2WbtgZAkTKt679sYtSudEQrTGWUSQAPe6MupLnlmaQ= -k8s.io/client-go v0.22.5/go.mod h1:cs6yf/61q2T1SdQL5Rdcjg9J1ElXSwbjSrW2vFImM4Y= -k8s.io/component-base v0.22.5/go.mod h1:VK3I+TjuF9eaa+Ln67dKxhGar5ynVbwnGrUiNF4MqCI= -k8s.io/cri-api v0.23.1/go.mod h1:REJE3PSU0h/LOV1APBrupxrEJqnoxZC8KWzkBUHwrK4= -k8s.io/cri-api v0.25.0/go.mod h1:J1rAyQkSJ2Q6I+aBMOVgg2/cbbebso6FNa0UagiR0kc= -k8s.io/klog/v2 v2.9.0/go.mod h1:hy9LJ/NvuK+iVyP4Ehqva4HxZG/oXyIS3n3Jmire4Ec= -k8s.io/klog/v2 v2.30.0/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= -k8s.io/kube-openapi v0.0.0-20210421082810-95288971da7e/go.mod h1:vHXdDvt9+2spS2Rx9ql3I8tycm3H9FDfdUoIuKCefvw= -k8s.io/kube-openapi v0.0.0-20211109043538-20434351676c/go.mod h1:vHXdDvt9+2spS2Rx9ql3I8tycm3H9FDfdUoIuKCefvw= -k8s.io/utils v0.0.0-20210819203725-bdf08cb9a70a/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= -k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= -mvdan.cc/gofumpt v0.4.0/go.mod h1:PljLOHDeZqgS8opHRKLzp2It2VBuSdteAgqUfzMTxlQ= -mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed/go.mod h1:Xkxe497xwlCKkIaQYRfC7CSLworTXY9RMqwhhCm+8Nc= -mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b/go.mod h1:2odslEg/xrtNQqCYg2/jCoyKnw3vv5biOc3JnIcYfL4= -mvdan.cc/unparam v0.0.0-20220706161116-678bad134442/go.mod h1:F/Cxw/6mVrNKqrR2YjFf5CaW0Bw4RL8RfbEf4GRggJk= -rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= -sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.22/go.mod h1:LEScyzhFmoF5pso/YSeBstl57mOzx9xlU9n85RGrDQg= -sigs.k8s.io/structured-merge-diff/v4 v4.1.2/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4= diff --git a/interchaintest/client_threshold_test.go b/interchaintest/client_threshold_test.go index fd77f70db..708aa2a48 100644 --- a/interchaintest/client_threshold_test.go +++ b/interchaintest/client_threshold_test.go @@ -5,12 +5,14 @@ import ( "fmt" "testing" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v7/relayer" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v8/relayer" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap" "go.uber.org/zap/zaptest" @@ -33,8 +35,22 @@ func TestScenarioClientThresholdUpdate(t *testing.T) { // Chain Factory cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ // Two otherwise identical chains that only differ by ChainName and ChainID. - {Name: "gaia", ChainName: "g0", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ChainID: g0ChainId}}, - {Name: "gaia", ChainName: "g1", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ChainID: g1ChainId}}, + { + Name: "gaia", + ChainName: "g0", + Version: "v14.1.0", + NumValidators: &nv, + NumFullNodes: &nf, + ChainConfig: ibc.ChainConfig{ChainID: g0ChainId}, + }, + { + Name: "gaia", + ChainName: "g1", + Version: "v14.1.0", + NumValidators: &nv, + NumFullNodes: &nf, + ChainConfig: ibc.ChainConfig{ChainID: g1ChainId}, + }, }) chains, err := cf.Chains(t.Name()) @@ -118,22 +134,42 @@ func TestScenarioClientThresholdUpdate(t *testing.T) { g1ClientID := g1Conns[0].ClientID + updateFound := func(found *clienttypes.MsgUpdateClient) bool { + return found != nil + } + var eg errgroup.Group eg.Go(func() error { - msg, err := pollForUpdateClient(ctx, g0, g0Height, g0Height+heightOffset) + msg, err := cosmos.PollForMessage( + ctx, + g0.(*cosmos.CosmosChain), + g0.Config().EncodingConfig.InterfaceRegistry, + g0Height, + g0Height+heightOffset, + updateFound, + ) if err != nil { - return fmt.Errorf("first chain: %w", err) + return fmt.Errorf("MsgUpdateClient not found for chain %s", g0.Config().ChainID) } + if msg.ClientId != g0ClientID { return fmt.Errorf("first chain: unexpected client id, want %s, got %s", g0ClientID, msg.ClientId) } return nil }) eg.Go(func() error { - msg, err := pollForUpdateClient(ctx, g1, g1Height, g1Height+heightOffset) + msg, err := cosmos.PollForMessage( + ctx, + g1.(*cosmos.CosmosChain), + g1.Config().EncodingConfig.InterfaceRegistry, + g1Height, + g1Height+heightOffset, + updateFound, + ) if err != nil { - return fmt.Errorf("second chain: %w", err) + return fmt.Errorf("MsgUpdateClient not found for chain %s", g1.Config().ChainID) } + if msg.ClientId != g1ClientID { return fmt.Errorf("second chain: unexpected client id, want %s, got %s", g1ClientID, msg.ClientId) } @@ -155,8 +191,22 @@ func TestScenarioClientTrustingPeriodUpdate(t *testing.T) { // Chain Factory cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ // Two otherwise identical chains that only differ by ChainID. - {Name: "gaia", ChainName: "g0", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ChainID: g0ChainId}}, - {Name: "gaia", ChainName: "g1", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ChainID: g1ChainId}}, + { + Name: "gaia", + ChainName: "g0", + Version: "v14.1.0", + NumValidators: &nv, + NumFullNodes: &nf, + ChainConfig: ibc.ChainConfig{ChainID: g0ChainId}, + }, + { + Name: "gaia", + ChainName: "g1", + Version: "v14.1.0", + NumValidators: &nv, + NumFullNodes: &nf, + ChainConfig: ibc.ChainConfig{ChainID: g1ChainId}, + }, }) chains, err := cf.Chains(t.Name()) @@ -242,19 +292,32 @@ func TestScenarioClientTrustingPeriodUpdate(t *testing.T) { g1ClientID := g1Conns[0].ClientID + updateFound := func(found *clienttypes.MsgUpdateClient) bool { + return found != nil + } + var eg errgroup.Group eg.Go(func() error { updatedG0Height, err := g0.Height(g0Ctx) require.NoError(t, err) logger.Info("G0 Chain height (2)", zap.String("g0 chainID", g0.Config().ChainID), zap.Uint64("g0 height", updatedG0Height)) - msg, err := pollForUpdateClient(g0Ctx, g0, updatedG0Height, updatedG0Height+heightOffset) + msg, err := cosmos.PollForMessage( + ctx, + g0.(*cosmos.CosmosChain), + g0.Config().EncodingConfig.InterfaceRegistry, + updatedG0Height, + updatedG0Height+heightOffset, + updateFound, + ) if err != nil { - return fmt.Errorf("first chain: %w", err) + return fmt.Errorf("MsgUpdateClient not found for chain %s", g0.Config().ChainID) } + if msg.ClientId != g0ClientID { return fmt.Errorf("first chain: unexpected client id, want %s, got %s", g0ClientID, msg.ClientId) } + return nil }) eg.Go(func() error { @@ -262,10 +325,18 @@ func TestScenarioClientTrustingPeriodUpdate(t *testing.T) { require.NoError(t, err) logger.Info("G1 Chain height (2)", zap.String("g1 chainID", g1.Config().ChainID), zap.Uint64("g1 height", updatedG1Height)) - msg, err := pollForUpdateClient(g1Ctx, g1, updatedG1Height, updatedG1Height+heightOffset) + msg, err := cosmos.PollForMessage( + ctx, + g1.(*cosmos.CosmosChain), + g1.Config().EncodingConfig.InterfaceRegistry, + updatedG1Height, + updatedG1Height+heightOffset, + updateFound, + ) if err != nil { - return fmt.Errorf("second chain: %w", err) + return fmt.Errorf("MsgUpdateClient not found for chain %s", g1.Config().ChainID) } + if msg.ClientId != g1ClientID { return fmt.Errorf("second chain: unexpected client id, want %s, got %s", g1ClientID, msg.ClientId) } diff --git a/interchaintest/fee_middleware_test.go b/interchaintest/fee_middleware_test.go index 850fe27d7..75070bf67 100644 --- a/interchaintest/fee_middleware_test.go +++ b/interchaintest/fee_middleware_test.go @@ -5,13 +5,14 @@ import ( "fmt" "testing" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" + sdkmath "cosmossdk.io/math" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" relayertest "github.com/cosmos/relayer/v2/interchaintest" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - ibc "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) @@ -26,9 +27,23 @@ func TestRelayerFeeMiddleware(t *testing.T) { // Get both chains cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ - {Name: "juno", ChainName: "chaina", Version: "v13.0.0", NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ChainID: "chaina", GasPrices: "0.0ujuno"}}, - {Name: "juno", ChainName: "chainb", Version: "v13.0.0", NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ChainID: "chainb", GasPrices: "0.0ujuno"}}}, - ) + { + Name: "juno", + ChainName: "chaina", + Version: "v13.0.0", + NumValidators: &nv, + NumFullNodes: &nf, + ChainConfig: ibc.ChainConfig{ChainID: "chaina", GasPrices: "0.0ujuno"}, + }, + { + Name: "juno", + ChainName: "chainb", + Version: "v13.0.0", + NumValidators: &nv, + NumFullNodes: &nf, + ChainConfig: ibc.ChainConfig{ChainID: "chainb", GasPrices: "0.0ujuno"}, + }, + }) chains, err := cf.Chains(t.Name()) require.NoError(t, err) @@ -89,8 +104,8 @@ func TestRelayerFeeMiddleware(t *testing.T) { channelA := chA[0] // Fund a user account on chain1 and chain2 - const userFunds = int64(1_000_000_000_000) - users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), userFunds, chainA, chainB) + initBal := sdkmath.NewInt(1_000_000_000_000) + users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), initBal, chainA, chainB) userA := users[0] userAddressA := userA.FormattedAddress() userB := users[1] @@ -129,22 +144,22 @@ func TestRelayerFeeMiddleware(t *testing.T) { // Get initial account balances userAOrigBal, err := chainA.GetBalance(ctx, userAddressA, chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, userFunds, userAOrigBal) + require.True(t, initBal.Equal(userAOrigBal)) userBOrigBal, err := chainB.GetBalance(ctx, userAddressB, chainB.Config().Denom) require.NoError(t, err) - require.Equal(t, userFunds, userBOrigBal) + require.True(t, initBal.Equal(userBOrigBal)) rlyAOrigBal, err := chainA.GetBalance(ctx, rlyAddressA, chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, userFunds, rlyAOrigBal) + require.True(t, initBal.Equal(rlyAOrigBal)) rlyBOrigBal, err := chainB.GetBalance(ctx, rlyAddressB, chainB.Config().Denom) require.NoError(t, err) - require.Equal(t, userFunds, rlyBOrigBal) + require.True(t, initBal.Equal(rlyBOrigBal)) // send tx - const txAmount = 1000 + txAmount := sdkmath.NewInt(1000) transfer := ibc.WalletAmount{Address: userAddressB, Denom: chainA.Config().Denom, Amount: txAmount} _, err = chainA.SendIBCTransfer(ctx, channelA.ChannelID, userAddressA, transfer, ibc.TransferOptions{}) require.NoError(t, err) @@ -174,7 +189,7 @@ func TestRelayerFeeMiddleware(t *testing.T) { func() { err := r.StopRelayer(ctx, eRep) if err != nil { - t.Logf("an error occured while stopping the relayer: %s", err) + t.Logf("an error occurred while stopping the relayer: %s", err) } }, ) @@ -188,15 +203,16 @@ func TestRelayerFeeMiddleware(t *testing.T) { chainADenomTrace := transfertypes.ParseDenomTrace(chainATokenDenom) // Get balances after the fees + expectedBal := userAOrigBal.Sub(txAmount.AddRaw(1000)) chainABal, err := chainA.GetBalance(ctx, userAddressA, chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, userAOrigBal-(txAmount+1000), chainABal) + require.True(t, expectedBal.Equal(chainABal)) chainBBal, err := chainB.GetBalance(ctx, userAddressB, chainADenomTrace.IBCDenom()) require.NoError(t, err) - require.Equal(t, int64(txAmount), chainBBal) + require.True(t, txAmount.Equal(chainBBal)) rlyABal, err := chainA.GetBalance(ctx, rlyAddressA, chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, rlyAOrigBal+1000, rlyABal) + require.True(t, rlyAOrigBal.AddRaw(1000).Equal(rlyABal)) } diff --git a/interchaintest/feegrant_test.go b/interchaintest/feegrant_test.go index 6c35f2793..9b9cbf951 100644 --- a/interchaintest/feegrant_test.go +++ b/interchaintest/feegrant_test.go @@ -9,21 +9,24 @@ import ( "testing" "time" + sdkmath "cosmossdk.io/math" + "cosmossdk.io/x/feegrant" "github.com/avast/retry-go/v4" - rpcclient "github.com/cometbft/cometbft/rpc/client" - ctypes "github.com/cometbft/cometbft/rpc/core/types" + coretypes "github.com/cometbft/cometbft/rpc/core/types" "github.com/cosmos/cosmos-sdk/types" txtypes "github.com/cosmos/cosmos-sdk/types/tx" "github.com/cosmos/go-bip39" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + "github.com/cosmos/relayer/v2/client" "github.com/cosmos/relayer/v2/relayer" "github.com/cosmos/relayer/v2/relayer/chains/cosmos" "github.com/cosmos/relayer/v2/relayer/processor" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + cosmosv8 "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" "golang.org/x/sync/errgroup" @@ -95,11 +98,11 @@ func TestRelayerFeeGrant(t *testing.T) { var tests = [][]*interchaintest.ChainSpec{ { - {Name: "gaia", ChainName: "gaia", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf}, + {Name: "gaia", ChainName: "gaia", Version: "v14.1.0", NumValidators: &nv, NumFullNodes: &nf}, {Name: "osmosis", ChainName: "osmosis", Version: "v14.0.1", NumValidators: &nv, NumFullNodes: &nf}, }, { - {Name: "gaia", ChainName: "gaia", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf}, + {Name: "gaia", ChainName: "gaia", Version: "v14.1.0", NumValidators: &nv, NumFullNodes: &nf}, {Name: "kujira", ChainName: "kujira", Version: "v0.8.7", NumValidators: &nv, NumFullNodes: &nf}, }, } @@ -160,37 +163,37 @@ func TestRelayerFeeGrant(t *testing.T) { osmosisChannel := gaiaChans[0].Counterparty // Create and Fund User Wallets - fundAmount := int64(10_000_000) + fundAmount := sdkmath.NewInt(10_000_000) // Tiny amount of funding, not enough to pay for a single TX fee (the GRANTER should be paying the fee) - granteeFundAmount := int64(10) + granteeFundAmount := sdkmath.NewInt(10) granteeKeyPrefix := "grantee1" grantee2KeyPrefix := "grantee2" grantee3KeyPrefix := "grantee3" granterKeyPrefix := "default" mnemonicAny := genMnemonic(t) - gaiaGranterWallet, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, granterKeyPrefix, mnemonicAny, int64(fundAmount), gaia) + gaiaGranterWallet, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, granterKeyPrefix, mnemonicAny, fundAmount, gaia) require.NoError(t, err) mnemonicAny = genMnemonic(t) - gaiaGranteeWallet, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, granteeKeyPrefix, mnemonicAny, int64(granteeFundAmount), gaia) + gaiaGranteeWallet, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, granteeKeyPrefix, mnemonicAny, granteeFundAmount, gaia) require.NoError(t, err) mnemonicAny = genMnemonic(t) - gaiaGrantee2Wallet, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, grantee2KeyPrefix, mnemonicAny, int64(granteeFundAmount), gaia) + gaiaGrantee2Wallet, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, grantee2KeyPrefix, mnemonicAny, granteeFundAmount, gaia) require.NoError(t, err) mnemonicAny = genMnemonic(t) - gaiaGrantee3Wallet, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, grantee3KeyPrefix, mnemonicAny, int64(granteeFundAmount), gaia) + gaiaGrantee3Wallet, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, grantee3KeyPrefix, mnemonicAny, granteeFundAmount, gaia) require.NoError(t, err) mnemonicAny = genMnemonic(t) - osmosisUser, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, "recipient", mnemonicAny, int64(fundAmount), osmosis) + osmosisUser, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, "recipient", mnemonicAny, fundAmount, osmosis) require.NoError(t, err) mnemonicAny = genMnemonic(t) - gaiaUser, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, "recipient", mnemonicAny, int64(fundAmount), gaia) + gaiaUser, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, "recipient", mnemonicAny, fundAmount, gaia) require.NoError(t, err) mnemonic := gaiaGranterWallet.Mnemonic() @@ -268,7 +271,7 @@ func TestRelayerFeeGrant(t *testing.T) { //You MUST run the configure feegrant command prior to starting the relayer, otherwise it'd be like you never set it up at all (within this test) //Note that Gaia supports feegrants, but Osmosis does not (x/feegrant module, or any compatible module, is not included in Osmosis SDK app modules) localRelayer := r.(*Relayer) - res := localRelayer.sys().Run(logger, "chains", "configure", "feegrant", "basicallowance", gaia.Config().ChainID, gaiaGranterWallet.KeyName(), "--grantees", granteeCsv, "--overwrite-granter") + res := localRelayer.Sys().Run(logger, "chains", "configure", "feegrant", "basicallowance", gaia.Config().ChainID, gaiaGranterWallet.KeyName(), "--grantees", granteeCsv, "--overwrite-granter") if res.Err != nil { fmt.Printf("configure feegrant results: %s\n", res.Stdout.String()) t.Fatalf("failed to rly config feegrants: %v", res.Err) @@ -282,7 +285,7 @@ func TestRelayerFeeGrant(t *testing.T) { r.StartRelayer(ctx, eRep, ibcPath) // Send Transaction - amountToSend := int64(1_000) + amountToSend := sdkmath.NewInt(1_000) gaiaDstAddress := types.MustBech32ifyAddressBytes(osmosis.Config().Bech32Prefix, gaiaUser.Address()) osmosisDstAddress := types.MustBech32ifyAddressBytes(gaia.Config().Bech32Prefix, osmosisUser.Address()) @@ -422,12 +425,15 @@ func TestRelayerFeeGrant(t *testing.T) { //It's required that TXs be feegranted in a round robin fashion for this chain and message type if isFeegrantedChain && isFeegrantedMsg { fmt.Printf("Msg types: %+v\n", msgs) - signers := fullTx.GetSigners() + + signers, _, err := cProv.Cdc.Marshaler.GetMsgV1Signers(fullTx) + require.NoError(t, err) + require.Equal(t, len(signers), 1) - granter := fullTx.FeeGranter() + granter := fullTx.FeeGranter(cProv.Cdc.Marshaler) //Feegranter for the TX that was signed on chain must be the relayer chain's configured feegranter - require.Equal(t, feegrantInfo.granter, granter.String()) + require.Equal(t, feegrantInfo.granter, string(granter)) require.NotEmpty(t, granter) for _, msg := range fullTx.GetMsgs() { @@ -449,7 +455,7 @@ func TestRelayerFeeGrant(t *testing.T) { //Grantee for the TX that was signed on chain must be a configured grantee in the relayer's chain feegrants. //In addition, the grantee must be used in round robin fashion //expectedGrantee := nextGrantee(feegrantInfo) - actualGrantee := signers[0].String() + actualGrantee := string(signers[0]) signerList, ok := feegrantMsgSigners[chain] if ok { signerList = append(signerList, actualGrantee) @@ -457,7 +463,7 @@ func TestRelayerFeeGrant(t *testing.T) { } else { feegrantMsgSigners[chain] = []string{actualGrantee} } - fmt.Printf("Chain: %s, msg type: %s, height: %d, signer: %s, granter: %s\n", chain, msgType, curr.Response.Height, actualGrantee, granter.String()) + fmt.Printf("Chain: %s, msg type: %s, height: %d, signer: %s, granter: %s\n", chain, msgType, curr.Response.Height, actualGrantee, string(granter)) } done() } @@ -512,30 +518,29 @@ func TestRelayerFeeGrant(t *testing.T) { // Test destination wallets have increased funds gaiaIBCBalance, err := osmosis.GetBalance(ctx, gaiaDstAddress, gaiaIbcDenom) require.NoError(t, err) - require.Equal(t, amountToSend, gaiaIBCBalance) + require.True(t, amountToSend.Equal(gaiaIBCBalance)) osmosisIBCBalance, err := gaia.GetBalance(ctx, osmosisDstAddress, osmosisIbcDenom) require.NoError(t, err) - require.Equal(t, 3*amountToSend, osmosisIBCBalance) + require.True(t, amountToSend.MulRaw(3).Equal(osmosisIBCBalance)) // Test grantee still has exact amount expected gaiaGranteeIBCBalance, err := gaia.GetBalance(ctx, gaiaGranteeAddr, gaia.Config().Denom) require.NoError(t, err) - require.Equal(t, granteeFundAmount, gaiaGranteeIBCBalance) + require.True(t, gaiaGranteeIBCBalance.Equal(granteeFundAmount)) // Test granter has less than they started with, meaning fees came from their account gaiaGranterIBCBalance, err := gaia.GetBalance(ctx, gaiaGranterAddr, gaia.Config().Denom) require.NoError(t, err) - require.Less(t, gaiaGranterIBCBalance, fundAmount) + require.True(t, gaiaGranterIBCBalance.LT(fundAmount)) r.StopRelayer(ctx, eRep) - }) } } -func TxWithRetry(ctx context.Context, client rpcclient.Client, hash []byte) (*ctypes.ResultTx, error) { +func TxWithRetry(ctx context.Context, client client.RPCClient, hash []byte) (*coretypes.ResultTx, error) { var err error - var res *ctypes.ResultTx + var res *coretypes.ResultTx if err = retry.Do(func() error { res, err = client.Tx(ctx, hash, true) return err @@ -545,3 +550,533 @@ func TxWithRetry(ctx context.Context, client rpcclient.Client, hash []byte) (*ct return res, err } + +// TestRelayerFeeGrantExternal Feegrant on a single chain where the granter is an externally controlled address (no private key). +// Run this test with e.g. go test -timeout 300s -run ^TestRelayerFeeGrantExternal$ github.com/cosmos/relayer/v2/ibctest. +func TestRelayerFeeGrantExternal(t *testing.T) { + ctx := context.Background() + logger := zaptest.NewLogger(t) + + nv := 1 + nf := 0 + + var tests = [][]*interchaintest.ChainSpec{ + { + {Name: "gaia", ChainName: "gaia", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf}, + {Name: "osmosis", ChainName: "osmosis", Version: "v14.0.1", NumValidators: &nv, NumFullNodes: &nf}, + }, + { + {Name: "gaia", ChainName: "gaia", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf}, + {Name: "kujira", ChainName: "kujira", Version: "v0.8.7", NumValidators: &nv, NumFullNodes: &nf}, + }, + } + + for _, tt := range tests { + testname := fmt.Sprintf("%s,%s", tt[0].Name, tt[1].Name) + t.Run(testname, func(t *testing.T) { + + // Chain Factory + cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), tt) + + chains, err := cf.Chains(t.Name()) + require.NoError(t, err) + gaia, osmosis := chains[0], chains[1] + + // Relayer Factory to construct relayer + r := NewRelayerFactory(RelayerConfig{ + Processor: relayer.ProcessorEvents, + InitialBlockHistory: 100, + }).Build(t, nil, "") + + processor.PathProcMessageCollector = make(chan *processor.PathProcessorMessageResp, 10000) + + // Prep Interchain + const ibcPath = "gaia-osmosis" + ic := interchaintest.NewInterchain(). + AddChain(gaia). + AddChain(osmosis). + AddRelayer(r, "relayer"). + AddLink(interchaintest.InterchainLink{ + Chain1: gaia, + Chain2: osmosis, + Relayer: r, + Path: ibcPath, + }) + + // Reporter/logs + rep := testreporter.NewNopReporter() + eRep := rep.RelayerExecReporter(t) + + client, network := interchaintest.DockerSetup(t) + + // Build interchain + require.NoError(t, ic.Build(ctx, eRep, interchaintest.InterchainBuildOptions{ + TestName: t.Name(), + Client: client, + NetworkID: network, + + SkipPathCreation: false, + })) + + t.Parallel() + + // Make sure feegrant codec is registered, since it is not by default + feegrant.RegisterInterfaces(gaia.Config().EncodingConfig.InterfaceRegistry) + + // Get Channel ID + gaiaChans, err := r.GetChannels(ctx, eRep, gaia.Config().ChainID) + require.NoError(t, err) + gaiaChannel := gaiaChans[0] + osmosisChannel := gaiaChans[0].Counterparty + + // Create and Fund User Wallets + fundAmount := sdkmath.NewInt(10_000_000) + + // Tiny amount of funding, not enough to pay for a single TX fee (the GRANTER should be paying the fee) + granteeKeyPrefix := "grantee1" + grantee2KeyPrefix := "grantee2" + grantee3KeyPrefix := "grantee3" + granterKeyPrefix := "default" + + mnemonicAny := genMnemonic(t) + + gaiaGranteeWallet, err := buildUserUnfunded(ctx, granteeKeyPrefix, mnemonicAny, gaia) + require.NoError(t, err) + + mnemonicAny = genMnemonic(t) + gaiaGrantee2Wallet, err := buildUserUnfunded(ctx, grantee2KeyPrefix, mnemonicAny, gaia) + require.NoError(t, err) + + mnemonicAny = genMnemonic(t) + gaiaGrantee3Wallet, err := buildUserUnfunded(ctx, grantee3KeyPrefix, mnemonicAny, gaia) + require.NoError(t, err) + + mnemonicAny = genMnemonic(t) + osmosisUser, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, "recipient", mnemonicAny, fundAmount, osmosis) + require.NoError(t, err) + + mnemonicAny = genMnemonic(t) + gaiaUser, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, "recipient", mnemonicAny, fundAmount, gaia) + require.NoError(t, err) + + // Fund the granter wallet on chain + mnemonicAny = genMnemonic(t) + gaiaGranterWallet, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, granterKeyPrefix, mnemonicAny, fundAmount, gaia) + require.NoError(t, err) + + // Set SDK context to the right bech32 prefix + prefix := gaia.Config().Bech32Prefix + done := cosmos.SetSDKConfigContext(prefix) + + // Feegrant each of the grantees + err = Feegrant(t, gaia.(*cosmosv8.CosmosChain), gaiaGranterWallet, gaiaGranterWallet.Address(), gaiaGranteeWallet.Address(), gaiaGranterWallet.FormattedAddress(), gaiaGranteeWallet.FormattedAddress()) + require.NoError(t, err) + err = Feegrant(t, gaia.(*cosmosv8.CosmosChain), gaiaGranterWallet, gaiaGranterWallet.Address(), gaiaGrantee2Wallet.Address(), gaiaGranterWallet.FormattedAddress(), gaiaGrantee2Wallet.FormattedAddress()) + require.NoError(t, err) + err = Feegrant(t, gaia.(*cosmosv8.CosmosChain), gaiaGranterWallet, gaiaGranterWallet.Address(), gaiaGrantee3Wallet.Address(), gaiaGranterWallet.FormattedAddress(), gaiaGrantee3Wallet.FormattedAddress()) + require.NoError(t, err) + done() + + mnemonic := gaiaGranterWallet.Mnemonic() + fmt.Printf("Wallet mnemonic: %s\n", mnemonic) + + rand.Seed(time.Now().UnixNano()) + + // Notably, we do not restore the key for 'gaiaGranterWallet' to the relayer config. + // The relayer does not need the granter private key since it is owned externally. + // Below, the relayer restores the keys for each of the grantee wallets. It signs TXs with these keys. + // IBC chain config (above) is unrelated to RELAYER config so this step is necessary. + if err := r.RestoreKey(ctx, + eRep, + gaia.Config(), + gaiaGranteeWallet.KeyName(), + gaiaGranteeWallet.Mnemonic(), + ); err != nil { + t.Fatalf("failed to restore granter key to relayer for chain %s: %s", gaia.Config().ChainID, err.Error()) + } + + //IBC chain config is unrelated to RELAYER config so this step is necessary + if err := r.RestoreKey(ctx, + eRep, + gaia.Config(), + gaiaGrantee2Wallet.KeyName(), + gaiaGrantee2Wallet.Mnemonic(), + ); err != nil { + t.Fatalf("failed to restore granter key to relayer for chain %s: %s", gaia.Config().ChainID, err.Error()) + } + + //IBC chain config is unrelated to RELAYER config so this step is necessary + if err := r.RestoreKey(ctx, + eRep, + gaia.Config(), + gaiaGrantee3Wallet.KeyName(), + gaiaGrantee3Wallet.Mnemonic(), + ); err != nil { + t.Fatalf("failed to restore granter key to relayer for chain %s: %s", gaia.Config().ChainID, err.Error()) + } + + //IBC chain config is unrelated to RELAYER config so this step is necessary + if err := r.RestoreKey(ctx, + eRep, + osmosis.Config(), + osmosisUser.KeyName(), + osmosisUser.Mnemonic(), + ); err != nil { + t.Fatalf("failed to restore granter key to relayer for chain %s: %s", osmosis.Config().ChainID, err.Error()) + } + + //IBC chain config is unrelated to RELAYER config so this step is necessary + if err := r.RestoreKey(ctx, + eRep, + osmosis.Config(), + gaiaUser.KeyName(), + gaiaUser.Mnemonic(), + ); err != nil { + t.Fatalf("failed to restore granter key to relayer for chain %s: %s", gaia.Config().ChainID, err.Error()) + } + + gaiaGranteeAddr := gaiaGranteeWallet.FormattedAddress() + gaiaGrantee2Addr := gaiaGrantee2Wallet.FormattedAddress() + gaiaGrantee3Addr := gaiaGrantee3Wallet.FormattedAddress() + gaiaGranterAddr := gaiaGranterWallet.FormattedAddress() + + granteeCsv := gaiaGranteeWallet.KeyName() + "," + gaiaGrantee2Wallet.KeyName() + "," + gaiaGrantee3Wallet.KeyName() + + //You MUST run the configure feegrant command prior to starting the relayer, otherwise it'd be like you never set it up at all (within this test) + //Note that Gaia supports feegrants, but Osmosis does not (x/feegrant module, or any compatible module, is not included in Osmosis SDK app modules) + localRelayer := r.(*Relayer) + res := localRelayer.Sys().Run(logger, "chains", "configure", "feegrant", "basicallowance", gaia.Config().ChainID, gaiaGranterWallet.FormattedAddress(), "--grantees", granteeCsv, "--overwrite-granter") + if res.Err != nil { + fmt.Printf("configure feegrant results: %s\n", res.Stdout.String()) + t.Fatalf("failed to rly config feegrants: %v", res.Err) + } + + //Map of feegranted chains and the feegrant info for the chain + feegrantedChains := map[string]*chainFeegrantInfo{} + feegrantedChains[gaia.Config().ChainID] = &chainFeegrantInfo{granter: gaiaGranterAddr, grantees: []string{gaiaGranteeAddr, gaiaGrantee2Addr, gaiaGrantee3Addr}} + + time.Sleep(14 * time.Second) //commit a couple blocks + r.StartRelayer(ctx, eRep, ibcPath) + + // Send Transaction + amountToSend := sdkmath.NewInt(1_000) + + gaiaDstAddress := types.MustBech32ifyAddressBytes(osmosis.Config().Bech32Prefix, gaiaUser.Address()) + osmosisDstAddress := types.MustBech32ifyAddressBytes(gaia.Config().Bech32Prefix, osmosisUser.Address()) + + gaiaHeight, err := gaia.Height(ctx) + require.NoError(t, err) + + osmosisHeight, err := osmosis.Height(ctx) + require.NoError(t, err) + + var eg errgroup.Group + var gaiaTx ibc.Tx + + eg.Go(func() error { + gaiaTx, err = gaia.SendIBCTransfer(ctx, gaiaChannel.ChannelID, gaiaUser.KeyName(), ibc.WalletAmount{ + Address: gaiaDstAddress, + Denom: gaia.Config().Denom, + Amount: amountToSend, + }, + ibc.TransferOptions{}, + ) + if err != nil { + return err + } + if err := gaiaTx.Validate(); err != nil { + return err + } + + _, err = testutil.PollForAck(ctx, gaia, gaiaHeight, gaiaHeight+20, gaiaTx.Packet) + return err + }) + + eg.Go(func() error { + tx, err := osmosis.SendIBCTransfer(ctx, osmosisChannel.ChannelID, osmosisUser.KeyName(), ibc.WalletAmount{ + Address: osmosisDstAddress, + Denom: osmosis.Config().Denom, + Amount: amountToSend, + }, + ibc.TransferOptions{}, + ) + if err != nil { + return err + } + if err := tx.Validate(); err != nil { + return err + } + _, err = testutil.PollForAck(ctx, osmosis, osmosisHeight, osmosisHeight+20, tx.Packet) + return err + }) + + eg.Go(func() error { + tx, err := osmosis.SendIBCTransfer(ctx, osmosisChannel.ChannelID, osmosisUser.KeyName(), ibc.WalletAmount{ + Address: osmosisDstAddress, + Denom: osmosis.Config().Denom, + Amount: amountToSend, + }, + ibc.TransferOptions{}, + ) + if err != nil { + return err + } + if err := tx.Validate(); err != nil { + return err + } + _, err = testutil.PollForAck(ctx, osmosis, osmosisHeight, osmosisHeight+20, tx.Packet) + return err + }) + + eg.Go(func() error { + tx, err := osmosis.SendIBCTransfer(ctx, osmosisChannel.ChannelID, osmosisUser.KeyName(), ibc.WalletAmount{ + Address: osmosisDstAddress, + Denom: osmosis.Config().Denom, + Amount: amountToSend, + }, + ibc.TransferOptions{}, + ) + if err != nil { + return err + } + if err := tx.Validate(); err != nil { + return err + } + _, err = testutil.PollForAck(ctx, osmosis, osmosisHeight, osmosisHeight+20, tx.Packet) + return err + }) + + require.NoError(t, err) + require.NoError(t, eg.Wait()) + + feegrantMsgSigners := map[string][]string{} //chain to list of signers + + for len(processor.PathProcMessageCollector) > 0 { + select { + case curr, ok := <-processor.PathProcMessageCollector: + if ok && curr.Error == nil && curr.SuccessfulTx { + cProv, cosmProv := curr.DestinationChain.(*cosmos.CosmosProvider) + if cosmProv { + chain := cProv.PCfg.ChainID + feegrantInfo, isFeegrantedChain := feegrantedChains[chain] + if isFeegrantedChain && !strings.Contains(cProv.PCfg.KeyDirectory, t.Name()) { + //This would indicate that a parallel test is inserting msgs into the queue. + //We can safely skip over any messages inserted by other test cases. + fmt.Println("Skipping PathProcessorMessageResp from unrelated Parallel test case") + continue + } + + done := cProv.SetSDKContext() + + hash, err := hex.DecodeString(curr.Response.TxHash) + require.Nil(t, err) + txResp, err := TxWithRetry(ctx, cProv.RPCClient, hash) + require.Nil(t, err) + + require.Nil(t, err) + dc := cProv.Cdc.TxConfig.TxDecoder() + tx, err := dc(txResp.Tx) + require.Nil(t, err) + builder, err := cProv.Cdc.TxConfig.WrapTxBuilder(tx) + require.Nil(t, err) + txFinder := builder.(protoTxProvider) + fullTx := txFinder.GetProtoTx() + isFeegrantedMsg := false + + msgs := "" + msgType := "" + for _, m := range fullTx.GetMsgs() { + msgType = types.MsgTypeURL(m) + //We want all IBC transfers (on an open channel/connection) to be feegranted in round robin fashion + if msgType == "/ibc.core.channel.v1.MsgRecvPacket" || msgType == "/ibc.core.channel.v1.MsgAcknowledgement" { + isFeegrantedMsg = true + msgs += msgType + ", " + } else { + msgs += msgType + ", " + } + } + + //It's required that TXs be feegranted in a round robin fashion for this chain and message type + if isFeegrantedChain && isFeegrantedMsg { + fmt.Printf("Msg types: %+v\n", msgs) + + signers, _, err := cProv.Cdc.Marshaler.GetMsgV1Signers(fullTx) + require.NoError(t, err) + + require.Equal(t, len(signers), 1) + granter := fullTx.FeeGranter(cProv.Cdc.Marshaler) + + //Feegranter for the TX that was signed on chain must be the relayer chain's configured feegranter + require.Equal(t, feegrantInfo.granter, string(granter)) + require.NotEmpty(t, granter) + + for _, msg := range fullTx.GetMsgs() { + msgType = types.MsgTypeURL(msg) + //We want all IBC transfers (on an open channel/connection) to be feegranted in round robin fashion + if msgType == "/ibc.core.channel.v1.MsgRecvPacket" { + c := msg.(*chantypes.MsgRecvPacket) + appData := c.Packet.GetData() + tokenTransfer := &transfertypes.FungibleTokenPacketData{} + err := tokenTransfer.Unmarshal(appData) + if err == nil { + fmt.Printf("%+v\n", tokenTransfer) + } else { + fmt.Println(string(appData)) + } + } + } + + //Grantee for the TX that was signed on chain must be a configured grantee in the relayer's chain feegrants. + //In addition, the grantee must be used in round robin fashion + //expectedGrantee := nextGrantee(feegrantInfo) + actualGrantee := string(signers[0]) + signerList, ok := feegrantMsgSigners[chain] + if ok { + signerList = append(signerList, actualGrantee) + feegrantMsgSigners[chain] = signerList + } else { + feegrantMsgSigners[chain] = []string{actualGrantee} + } + fmt.Printf("Chain: %s, msg type: %s, height: %d, signer: %s, granter: %s\n", chain, msgType, curr.Response.Height, actualGrantee, string(granter)) + } + done() + } + } + default: + fmt.Println("Unknown channel message") + } + } + + for chain, signers := range feegrantMsgSigners { + require.Equal(t, chain, gaia.Config().ChainID) + signerCountMap := map[string]int{} + + for _, signer := range signers { + count, ok := signerCountMap[signer] + if ok { + signerCountMap[signer] = count + 1 + } else { + signerCountMap[signer] = 1 + } + } + + highestCount := 0 + for _, count := range signerCountMap { + if count > highestCount { + highestCount = count + } + } + + //At least one feegranter must have signed a TX + require.GreaterOrEqual(t, highestCount, 1) + + //All of the feegrantees must have signed at least one TX + expectedFeegrantInfo := feegrantedChains[chain] + require.Equal(t, len(signerCountMap), len(expectedFeegrantInfo.grantees)) + + // verify that TXs were signed in a round robin fashion. + // no grantee should have signed more TXs than any other grantee (off by one is allowed). + for signer, count := range signerCountMap { + fmt.Printf("signer %s signed %d feegranted TXs \n", signer, count) + require.LessOrEqual(t, highestCount-count, 1) + } + } + + // Trace IBC Denom + gaiaDenomTrace := transfertypes.ParseDenomTrace(transfertypes.GetPrefixedDenom(osmosisChannel.PortID, osmosisChannel.ChannelID, gaia.Config().Denom)) + gaiaIbcDenom := gaiaDenomTrace.IBCDenom() + + osmosisDenomTrace := transfertypes.ParseDenomTrace(transfertypes.GetPrefixedDenom(gaiaChannel.PortID, gaiaChannel.ChannelID, osmosis.Config().Denom)) + osmosisIbcDenom := osmosisDenomTrace.IBCDenom() + + // Test destination wallets have increased funds + gaiaIBCBalance, err := osmosis.GetBalance(ctx, gaiaDstAddress, gaiaIbcDenom) + require.NoError(t, err) + require.True(t, amountToSend.Equal(gaiaIBCBalance)) + + osmosisIBCBalance, err := gaia.GetBalance(ctx, osmosisDstAddress, osmosisIbcDenom) + require.NoError(t, err) + require.True(t, amountToSend.MulRaw(3).Equal(osmosisIBCBalance)) + + // Test grantee still has exact amount expected + gaiaGranteeIBCBalance, err := gaia.GetBalance(ctx, gaiaGranteeAddr, gaia.Config().Denom) + require.NoError(t, err) + require.True(t, gaiaGranteeIBCBalance.Equal(sdkmath.ZeroInt())) + + // Test granter has less than they started with, meaning fees came from their account + gaiaGranterIBCBalance, err := gaia.GetBalance(ctx, gaiaGranterAddr, gaia.Config().Denom) + require.NoError(t, err) + require.True(t, gaiaGranterIBCBalance.LT(fundAmount)) + r.StopRelayer(ctx, eRep) + }) + } +} + +func buildUserUnfunded( + ctx context.Context, + keyNamePrefix, mnemonic string, + chain ibc.Chain, +) (ibc.Wallet, error) { + chainCfg := chain.Config() + keyName := fmt.Sprintf("%s-%s-%s", keyNamePrefix, chainCfg.ChainID, randLowerCaseLetterString(3)) + user, err := chain.BuildWallet(ctx, keyName, mnemonic) + if err != nil { + return nil, fmt.Errorf("failed to get source user wallet: %w", err) + } + + return user, nil +} + +var chars = []byte("abcdefghijklmnopqrstuvwxyz") + +// RandLowerCaseLetterString returns a lowercase letter string of given length +func randLowerCaseLetterString(length int) string { + b := make([]byte, length) + for i := range b { + b[i] = chars[rand.Intn(len(chars))] + } + return string(b) +} + +func Feegrant( + t *testing.T, + chain *cosmosv8.CosmosChain, + granterWallet ibc.Wallet, + granter types.AccAddress, + grantee types.AccAddress, + granterAddr string, + granteeAddr string, +) error { + // attempt to update client with duplicate header + b := cosmosv8.NewBroadcaster(t, chain) + + thirtyMin := time.Now().Add(30 * time.Minute) + feeGrantBasic := &feegrant.BasicAllowance{ + Expiration: &thirtyMin, + } + msgGrantAllowance, err := feegrant.NewMsgGrantAllowance(feeGrantBasic, granter, grantee) + if err != nil { + fmt.Printf("Error: feegrant.NewMsgGrantAllowance: %s", err.Error()) + return err + } + + // ensure correct bech32 prefix + msgGrantAllowance.Grantee = granteeAddr + msgGrantAllowance.Granter = granterAddr + + resp, err := cosmosv8.BroadcastTx(context.Background(), b, granterWallet, msgGrantAllowance) + require.NoError(t, err) + assertTransactionIsValid(t, resp) + return nil +} + +func assertTransactionIsValid(t *testing.T, resp types.TxResponse) { + t.Helper() + require.NotNil(t, resp) + require.NotEqual(t, 0, resp.GasUsed) + require.NotEqual(t, 0, resp.GasWanted) + require.Equal(t, uint32(0), resp.Code) + require.NotEmpty(t, resp.Data) + require.NotEmpty(t, resp.TxHash) + require.NotEmpty(t, resp.Events) +} diff --git a/interchaintest/go.mod b/interchaintest/go.mod index 7952e9d62..7d2681a80 100644 --- a/interchaintest/go.mod +++ b/interchaintest/go.mod @@ -3,86 +3,98 @@ module github.com/cosmos/relayer/v2/interchaintest go 1.21 require ( + cosmossdk.io/math v1.2.0 cosmossdk.io/simapp v0.0.0-20230224204036-a6adb0821462 - github.com/avast/retry-go/v4 v4.3.4 - github.com/cometbft/cometbft v0.37.2 - github.com/cosmos/cosmos-sdk v0.47.5 + cosmossdk.io/x/feegrant v0.1.0 + cosmossdk.io/x/upgrade v0.1.0 + github.com/avast/retry-go/v4 v4.5.1 + github.com/cometbft/cometbft v0.38.5 + github.com/cosmos/cosmos-sdk v0.50.4 github.com/cosmos/go-bip39 v1.0.0 - github.com/cosmos/gogoproto v1.4.10 - github.com/cosmos/ibc-go/v7 v7.3.0 + github.com/cosmos/gogoproto v1.4.11 + github.com/cosmos/ibc-go/modules/capability v1.0.0 + github.com/cosmos/ibc-go/v8 v8.0.0 github.com/cosmos/relayer/v2 v2.0.0 - github.com/docker/docker v24.0.1+incompatible - github.com/google/uuid v1.3.0 + github.com/docker/docker v24.0.7+incompatible + github.com/google/uuid v1.4.0 github.com/icza/dyno v0.0.0-20220812133438-f0b6f8a18845 - github.com/moby/moby v24.0.2+incompatible - github.com/strangelove-ventures/interchaintest/v7 v7.0.0-20230608002938-79172615eed0 + github.com/moby/moby v24.0.9+incompatible + github.com/strangelove-ventures/interchaintest/v8 v8.0.1-0.20231114192524-e3719592933b github.com/stretchr/testify v1.8.4 - go.uber.org/zap v1.24.0 - golang.org/x/sync v0.2.0 + go.uber.org/zap v1.26.0 + golang.org/x/sync v0.6.0 + gopkg.in/yaml.v3 v3.0.1 ) require ( - cloud.google.com/go v0.110.4 // indirect - cloud.google.com/go/compute v1.20.1 // indirect + cloud.google.com/go v0.110.10 // indirect + cloud.google.com/go/compute v1.23.3 // indirect cloud.google.com/go/compute/metadata v0.2.3 // indirect - cloud.google.com/go/iam v1.1.0 // indirect - cloud.google.com/go/storage v1.30.1 // indirect - cosmossdk.io/api v0.3.1 // indirect - cosmossdk.io/core v0.5.1 // indirect + cloud.google.com/go/iam v1.1.5 // indirect + cloud.google.com/go/storage v1.35.1 // indirect + cosmossdk.io/api v0.7.3 // indirect + cosmossdk.io/client/v2 v2.0.0-beta.1 // indirect + cosmossdk.io/collections v0.4.0 // indirect + cosmossdk.io/core v0.11.0 // indirect cosmossdk.io/depinject v1.0.0-alpha.4 // indirect - cosmossdk.io/errors v1.0.0 // indirect - cosmossdk.io/log v1.2.1 // indirect - cosmossdk.io/math v1.1.2 // indirect - cosmossdk.io/tools/rosetta v0.2.1 // indirect + cosmossdk.io/errors v1.0.1 // indirect + cosmossdk.io/log v1.3.1 // indirect + cosmossdk.io/store v1.0.2 // indirect + cosmossdk.io/x/circuit v0.1.0 // indirect + cosmossdk.io/x/evidence v0.1.0 // indirect + cosmossdk.io/x/tx v0.13.0 // indirect filippo.io/edwards25519 v1.0.0 // indirect github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect github.com/99designs/keyring v1.2.2 // indirect - github.com/BurntSushi/toml v1.3.0 // indirect + github.com/BurntSushi/toml v1.3.2 // indirect github.com/ChainSafe/go-schnorrkel v1.0.0 // indirect github.com/ChainSafe/go-schnorrkel/1 v0.0.0-00010101000000-000000000000 // indirect github.com/ComposableFi/go-subkey/v2 v2.0.0-tm03420 // indirect + github.com/DataDog/datadog-go v3.2.0+incompatible // indirect + github.com/DataDog/zstd v1.5.5 // indirect github.com/FactomProject/basen v0.0.0-20150613233007-fe3947df716e // indirect github.com/FactomProject/btcutilecc v0.0.0-20130527213604-d3a63a5752ec // indirect - github.com/Microsoft/go-winio v0.6.0 // indirect + github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/OneOfOne/xxhash v1.2.8 // indirect github.com/StirlingMarketingGroup/go-namecase v1.0.0 // indirect - github.com/armon/go-metrics v0.4.1 // indirect - github.com/aws/aws-sdk-go v1.44.203 // indirect - github.com/benbjohnson/clock v1.3.0 // indirect + github.com/aws/aws-sdk-go v1.44.312 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d // indirect github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 // indirect - github.com/btcsuite/btcd v0.23.4 // indirect + github.com/bits-and-blooms/bitset v1.10.0 // indirect + github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd // indirect github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect - github.com/btcsuite/btcd/btcutil v1.1.3 // indirect - github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 // indirect - github.com/cenkalti/backoff/v4 v4.1.3 // indirect + github.com/btcsuite/btcd/btcutil v1.1.5 // indirect + github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 // indirect + github.com/cenkalti/backoff/v4 v4.2.1 // indirect github.com/cespare/xxhash v1.1.0 // indirect github.com/cespare/xxhash/v2 v2.2.0 // indirect github.com/chzyer/readline v1.5.1 // indirect github.com/cockroachdb/apd/v2 v2.0.2 // indirect - github.com/cockroachdb/errors v1.10.0 // indirect + github.com/cockroachdb/errors v1.11.1 // indirect github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect + github.com/cockroachdb/pebble v1.1.0 // indirect github.com/cockroachdb/redact v1.1.5 // indirect - github.com/coinbase/rosetta-sdk-go/types v1.0.0 // indirect - github.com/cometbft/cometbft-db v0.8.0 // indirect - github.com/confio/ics23/go v0.9.0 // indirect - github.com/containerd/containerd v1.6.8 // indirect + github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect + github.com/cometbft/cometbft-db v0.9.1 // indirect + github.com/consensys/bavard v0.1.13 // indirect + github.com/consensys/gnark-crypto v0.12.1 // indirect + github.com/containerd/containerd v1.7.11 // indirect github.com/cosmos/btcutil v1.0.5 // indirect - github.com/cosmos/cosmos-proto v1.0.0-beta.2 // indirect + github.com/cosmos/cosmos-db v1.0.0 // indirect + github.com/cosmos/cosmos-proto v1.0.0-beta.4 // indirect github.com/cosmos/gogogateway v1.2.0 // indirect - github.com/cosmos/iavl v0.20.0 // indirect - github.com/cosmos/ibc-go/modules/capability v1.0.0-rc1 // indirect + github.com/cosmos/iavl v1.0.1 // indirect github.com/cosmos/ics23/go v0.10.0 // indirect - github.com/cosmos/ledger-cosmos-go v0.12.2 // indirect - github.com/cosmos/rosetta-sdk-go v0.10.0 // indirect - github.com/creachadair/taskgroup v0.4.2 // indirect + github.com/cosmos/ledger-cosmos-go v0.13.3 // indirect + github.com/crate-crypto/go-kzg-4844 v0.7.0 // indirect github.com/danieljoos/wincred v1.1.2 // indirect - github.com/davecgh/go-spew v1.1.1 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/deckarep/golang-set v1.8.0 // indirect github.com/decred/base58 v1.0.4 // indirect - github.com/decred/dcrd/crypto/blake256 v1.0.0 // indirect - github.com/decred/dcrd/dcrec/secp256k1/v2 v2.0.0 // indirect - github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect + github.com/decred/dcrd/crypto/blake256 v1.0.1 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v2 v2.0.1 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f // indirect github.com/dgraph-io/badger/v2 v2.2007.4 // indirect github.com/dgraph-io/ristretto v0.1.1 // indirect @@ -91,167 +103,177 @@ require ( github.com/docker/go-connections v0.4.0 // indirect github.com/docker/go-units v0.5.0 // indirect github.com/dustin/go-humanize v1.0.1 // indirect - github.com/dvsekhvalnov/jose2go v1.5.0 // indirect - github.com/ethereum/go-ethereum v1.10.26 // indirect - github.com/felixge/httpsnoop v1.0.2 // indirect - github.com/fsnotify/fsnotify v1.6.0 // indirect - github.com/getsentry/sentry-go v0.23.0 // indirect + github.com/dvsekhvalnov/jose2go v1.6.0 // indirect + github.com/emicklei/dot v1.6.1 // indirect + github.com/ethereum/c-kzg-4844 v0.4.0 // indirect + github.com/ethereum/go-ethereum v1.13.14 // indirect + github.com/fatih/color v1.15.0 // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/fsnotify/fsnotify v1.7.0 // indirect + github.com/getsentry/sentry-go v0.27.0 // indirect github.com/go-kit/kit v0.12.0 // indirect github.com/go-kit/log v0.2.1 // indirect github.com/go-logfmt/logfmt v0.6.0 // indirect - github.com/go-stack/stack v1.8.1 // indirect github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirect github.com/gofrs/flock v0.8.1 // indirect github.com/gogo/googleapis v1.4.1 // indirect github.com/gogo/protobuf v1.3.3 // indirect - github.com/golang/glog v1.1.0 // indirect + github.com/golang/glog v1.2.0 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/mock v1.6.0 // indirect github.com/golang/protobuf v1.5.3 // indirect - github.com/golang/snappy v0.0.4 // indirect + github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect github.com/google/btree v1.1.2 // indirect - github.com/google/go-cmp v0.5.9 // indirect + github.com/google/go-cmp v0.6.0 // indirect github.com/google/go-github/v43 v43.0.0 // indirect github.com/google/go-querystring v1.1.0 // indirect github.com/google/orderedcode v0.0.1 // indirect - github.com/google/s2a-go v0.1.4 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.2.3 // indirect - github.com/googleapis/gax-go/v2 v2.11.0 // indirect - github.com/gorilla/handlers v1.5.1 // indirect - github.com/gorilla/mux v1.8.0 // indirect - github.com/gorilla/websocket v1.5.0 // indirect - github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect + github.com/google/s2a-go v0.1.7 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect + github.com/googleapis/gax-go/v2 v2.12.0 // indirect + github.com/gorilla/handlers v1.5.2 // indirect + github.com/gorilla/mux v1.8.1 // indirect + github.com/gorilla/websocket v1.5.1 // indirect + github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 // indirect github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c // indirect github.com/gtank/merlin v0.1.1 // indirect github.com/gtank/ristretto255 v0.1.2 // indirect github.com/hashicorp/go-cleanhttp v0.5.2 // indirect - github.com/hashicorp/go-getter v1.7.1 // indirect + github.com/hashicorp/go-getter v1.7.2 // indirect + github.com/hashicorp/go-hclog v1.5.0 // indirect github.com/hashicorp/go-immutable-radix v1.3.1 // indirect + github.com/hashicorp/go-metrics v0.5.1 // indirect + github.com/hashicorp/go-plugin v1.5.2 // indirect github.com/hashicorp/go-safetemp v1.0.0 // indirect github.com/hashicorp/go-version v1.6.0 // indirect - github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect + github.com/hashicorp/golang-lru v1.0.2 // indirect github.com/hashicorp/hcl v1.0.0 // indirect + github.com/hashicorp/yamux v0.1.1 // indirect github.com/hdevalence/ed25519consensus v0.1.0 // indirect - github.com/holiman/uint256 v1.2.0 // indirect + github.com/holiman/uint256 v1.2.4 // indirect github.com/huandu/skiplist v1.2.0 // indirect + github.com/iancoleman/strcase v0.3.0 // indirect github.com/improbable-eng/grpc-web v0.15.0 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect - github.com/ipfs/go-cid v0.2.0 // indirect + github.com/ipfs/go-cid v0.4.1 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/jmhodges/levigo v1.0.0 // indirect github.com/jsternberg/zap-logfmt v1.3.0 // indirect github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect - github.com/klauspost/compress v1.16.3 // indirect - github.com/klauspost/cpuid/v2 v2.2.3 // indirect + github.com/klauspost/compress v1.17.6 // indirect + github.com/klauspost/cpuid/v2 v2.2.5 // indirect github.com/kr/pretty v0.3.1 // indirect github.com/kr/text v0.2.0 // indirect github.com/lib/pq v1.10.7 // indirect github.com/libp2p/go-buffer-pool v0.1.0 // indirect - github.com/libp2p/go-libp2p v0.22.0 // indirect - github.com/libp2p/go-openssl v0.1.0 // indirect - github.com/linxGnu/grocksdb v1.7.16 // indirect + github.com/libp2p/go-libp2p v0.31.0 // indirect + github.com/linxGnu/grocksdb v1.8.12 // indirect github.com/magiconair/properties v1.8.7 // indirect github.com/manifoldco/promptui v0.9.0 // indirect github.com/mattn/go-colorable v0.1.13 // indirect - github.com/mattn/go-isatty v0.0.19 // indirect - github.com/mattn/go-pointer v0.0.1 // indirect - github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect github.com/mimoo/StrobeGo v0.0.0-20220103164710-9a04d6ca976b // indirect github.com/minio/highwayhash v1.0.2 // indirect - github.com/minio/sha256-simd v1.0.0 // indirect - github.com/misko9/go-substrate-rpc-client/v4 v4.0.0-20230413215336-5bd2aea337ae // indirect + github.com/minio/sha256-simd v1.0.1 // indirect + github.com/misko9/go-substrate-rpc-client/v4 v4.0.0-20230913220906-b988ea7da0c2 // indirect github.com/mitchellh/go-homedir v1.1.0 // indirect github.com/mitchellh/go-testing-interface v1.14.1 // indirect github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/mmcloughlin/addchain v0.4.0 // indirect github.com/moby/patternmatcher v0.5.0 // indirect github.com/moby/sys/sequential v0.5.0 // indirect github.com/mr-tron/base58 v1.2.0 // indirect github.com/mtibben/percent v0.2.1 // indirect - github.com/multiformats/go-base32 v0.0.4 // indirect - github.com/multiformats/go-base36 v0.1.0 // indirect - github.com/multiformats/go-multiaddr v0.6.0 // indirect - github.com/multiformats/go-multibase v0.1.1 // indirect - github.com/multiformats/go-multicodec v0.5.0 // indirect - github.com/multiformats/go-multihash v0.2.1 // indirect - github.com/multiformats/go-varint v0.0.6 // indirect + github.com/multiformats/go-base32 v0.1.0 // indirect + github.com/multiformats/go-base36 v0.2.0 // indirect + github.com/multiformats/go-multiaddr v0.11.0 // indirect + github.com/multiformats/go-multibase v0.2.0 // indirect + github.com/multiformats/go-multicodec v0.9.0 // indirect + github.com/multiformats/go-multihash v0.2.3 // indirect + github.com/multiformats/go-varint v0.0.7 // indirect + github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a // indirect + github.com/oklog/run v1.1.0 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect - github.com/opencontainers/image-spec v1.1.0-rc2 // indirect - github.com/opencontainers/runc v1.1.3 // indirect + github.com/opencontainers/image-spec v1.1.0-rc2.0.20221005185240-3a7f492d3f1b // indirect + github.com/opencontainers/runc v1.1.12 // indirect github.com/pelletier/go-toml v1.9.5 // indirect - github.com/pelletier/go-toml/v2 v2.0.8 // indirect - github.com/petermattis/goid v0.0.0-20230317030725-371a4b8eda08 // indirect + github.com/pelletier/go-toml/v2 v2.1.0 // indirect + github.com/petermattis/goid v0.0.0-20230904192822-1876fd5063bc // indirect github.com/pierrec/xxHash v0.1.5 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/prometheus/client_golang v1.15.0 // indirect - github.com/prometheus/client_model v0.3.0 // indirect - github.com/prometheus/common v0.42.0 // indirect - github.com/prometheus/procfs v0.9.0 // indirect - github.com/rakyll/statik v0.1.7 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/prometheus/client_golang v1.18.0 // indirect + github.com/prometheus/client_model v0.6.0 // indirect + github.com/prometheus/common v0.47.0 // indirect + github.com/prometheus/procfs v0.12.0 // indirect github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect - github.com/rogpeppe/go-internal v1.11.0 // indirect + github.com/rogpeppe/go-internal v1.12.0 // indirect github.com/rs/cors v1.8.3 // indirect - github.com/rs/zerolog v1.30.0 // indirect + github.com/rs/zerolog v1.32.0 // indirect + github.com/sagikazarmark/locafero v0.4.0 // indirect + github.com/sagikazarmark/slog-shim v0.1.0 // indirect github.com/sasha-s/go-deadlock v0.3.1 // indirect - github.com/sirupsen/logrus v1.9.0 // indirect - github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 // indirect + github.com/sirupsen/logrus v1.9.3 // indirect + github.com/sourcegraph/conc v0.3.0 // indirect github.com/spaolacci/murmur3 v1.1.0 // indirect - github.com/spf13/afero v1.9.5 // indirect - github.com/spf13/cast v1.5.1 // indirect - github.com/spf13/cobra v1.7.0 // indirect - github.com/spf13/jwalterweatherman v1.1.0 // indirect + github.com/spf13/afero v1.11.0 // indirect + github.com/spf13/cast v1.6.0 // indirect + github.com/spf13/cobra v1.8.0 // indirect github.com/spf13/pflag v1.0.5 // indirect - github.com/spf13/viper v1.16.0 // indirect - github.com/subosito/gotenv v1.4.2 // indirect + github.com/spf13/viper v1.18.2 // indirect + github.com/strangelove-ventures/cometbft-client v0.1.0 // indirect + github.com/subosito/gotenv v1.6.0 // indirect + github.com/supranational/blst v0.3.11 // indirect github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d // indirect github.com/tendermint/go-amino v0.16.0 // indirect - github.com/tidwall/btree v1.6.0 // indirect + github.com/tidwall/btree v1.7.0 // indirect github.com/tyler-smith/go-bip32 v1.0.0 // indirect github.com/tyler-smith/go-bip39 v1.1.0 // indirect github.com/ulikunitz/xz v0.5.11 // indirect - github.com/zondax/hid v0.9.1 // indirect - github.com/zondax/ledger-go v0.14.1 // indirect - go.etcd.io/bbolt v1.3.7 // indirect + github.com/zondax/hid v0.9.2 // indirect + github.com/zondax/ledger-go v0.14.3 // indirect + go.etcd.io/bbolt v1.3.8 // indirect go.opencensus.io v0.24.0 // indirect - go.uber.org/atomic v1.10.0 // indirect go.uber.org/multierr v1.11.0 // indirect - golang.org/x/crypto v0.11.0 // indirect - golang.org/x/exp v0.0.0-20230711153332-06a737ee72cb // indirect - golang.org/x/mod v0.11.0 // indirect - golang.org/x/net v0.12.0 // indirect - golang.org/x/oauth2 v0.8.0 // indirect - golang.org/x/sys v0.11.0 // indirect - golang.org/x/term v0.10.0 // indirect - golang.org/x/text v0.12.0 // indirect - golang.org/x/tools v0.9.3 // indirect + golang.org/x/crypto v0.19.0 // indirect + golang.org/x/exp v0.0.0-20240213143201-ec583247a57a // indirect + golang.org/x/mod v0.15.0 // indirect + golang.org/x/net v0.21.0 // indirect + golang.org/x/oauth2 v0.16.0 // indirect + golang.org/x/sys v0.17.0 // indirect + golang.org/x/term v0.17.0 // indirect + golang.org/x/text v0.14.0 // indirect + golang.org/x/time v0.5.0 // indirect + golang.org/x/tools v0.18.0 // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect - google.golang.org/api v0.126.0 // indirect - google.golang.org/appengine v1.6.7 // indirect - google.golang.org/genproto v0.0.0-20230706204954-ccb25ca9f130 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20230629202037-9506855d4529 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98 // indirect - google.golang.org/grpc v1.56.2 // indirect - google.golang.org/protobuf v1.31.0 // indirect + google.golang.org/api v0.153.0 // indirect + google.golang.org/appengine v1.6.8 // indirect + google.golang.org/genproto v0.0.0-20231211222908-989df2bf70f3 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20231120223509-83a465c0220f // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20231212172506-995d672761c0 // indirect + google.golang.org/grpc v1.60.1 // indirect + google.golang.org/protobuf v1.32.0 // indirect gopkg.in/ini.v1 v1.67.0 // indirect gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect gopkg.in/yaml.v2 v2.4.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect - lukechampine.com/blake3 v1.1.7 // indirect + gotest.tools/v3 v3.5.1 // indirect + lukechampine.com/blake3 v1.2.1 // indirect lukechampine.com/uint128 v1.2.0 // indirect modernc.org/cc/v3 v3.40.0 // indirect modernc.org/ccgo/v3 v3.16.13 // indirect - modernc.org/libc v1.22.5 // indirect - modernc.org/mathutil v1.5.0 // indirect - modernc.org/memory v1.5.0 // indirect + modernc.org/libc v1.29.0 // indirect + modernc.org/mathutil v1.6.0 // indirect + modernc.org/memory v1.7.2 // indirect modernc.org/opt v0.1.3 // indirect - modernc.org/sqlite v1.23.0 // indirect + modernc.org/sqlite v1.27.0 // indirect modernc.org/strutil v1.1.3 // indirect modernc.org/token v1.0.1 // indirect - nhooyr.io/websocket v1.8.6 // indirect - pgregory.net/rapid v0.5.5 // indirect - sigs.k8s.io/yaml v1.3.0 // indirect + nhooyr.io/websocket v1.8.7 // indirect + pgregory.net/rapid v1.1.0 // indirect + rsc.io/tmplfunc v0.0.3 // indirect + sigs.k8s.io/yaml v1.4.0 // indirect ) replace ( diff --git a/interchaintest/go.sum b/interchaintest/go.sum index ef668b4a7..603a40097 100644 --- a/interchaintest/go.sum +++ b/interchaintest/go.sum @@ -3,7 +3,6 @@ cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= -cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= @@ -16,7 +15,6 @@ cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOY cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= -cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= @@ -32,8 +30,8 @@ cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w9 cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= -cloud.google.com/go v0.110.4 h1:1JYyxKMN9hd5dR2MYTPWkGUgcoxVVhg0LKNKEo0qvmk= -cloud.google.com/go v0.110.4/go.mod h1:+EYjdK8e5RME/VY/qLCAtuyALQ9q67dvuum8i+H5xsI= +cloud.google.com/go v0.110.10 h1:LXy9GEO+timppncPIAZoOj3l58LIU9k+kn48AN7IO3Y= +cloud.google.com/go v0.110.10/go.mod h1:v1OoFqYxiBkUrruItNM3eT4lLByNjxmJSV/xDKJNnic= cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= @@ -70,8 +68,8 @@ cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= -cloud.google.com/go/compute v1.20.1 h1:6aKEtlUiwEpJzM001l0yFkpXmUVXaN8W+fbkb2AZNbg= -cloud.google.com/go/compute v1.20.1/go.mod h1:4tCnrn48xsqlwSAiLf1HXMQk8CONslYbdiEZc9FEIbM= +cloud.google.com/go/compute v1.23.3 h1:6sVlXXBmbd7jNX0Ipq0trII3e4n1/MsADLK6a+aiVlk= +cloud.google.com/go/compute v1.23.3/go.mod h1:VCgBUoMnIVIR0CscqQiPJLAG25E3ZRZMzcFZeQ+h8CI= cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY= cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= @@ -111,8 +109,8 @@ cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y97 cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= -cloud.google.com/go/iam v1.1.0 h1:67gSqaPukx7O8WLLHMa0PNs3EBGd2eE4d+psbO/CO94= -cloud.google.com/go/iam v1.1.0/go.mod h1:nxdHjaKfCr7fNYx/HJMM8LgiMugmveWlkatear5gVyk= +cloud.google.com/go/iam v1.1.5 h1:1jTsCu4bcsNsE4iiqNT5SHwrDRCfRmIaaaVFhRveTJI= +cloud.google.com/go/iam v1.1.5/go.mod h1:rB6P/Ic3mykPbFio+vo7403drjlgvoWfYpJhMXEbzv8= cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= @@ -170,12 +168,11 @@ cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0Zeo cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= -cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= -cloud.google.com/go/storage v1.30.1 h1:uOdMxAs8HExqBlnLtnQyP0YkvbiDpdGShGKtx6U/oNM= -cloud.google.com/go/storage v1.30.1/go.mod h1:NfxhC0UJE1aXSx7CIIbCf7y9HKT7BiccwkR7+P7gN8E= +cloud.google.com/go/storage v1.35.1 h1:B59ahL//eDfx2IIKFBeT5Atm9wnNmj3+8xG/W4WB//w= +cloud.google.com/go/storage v1.35.1/go.mod h1:M6M/3V/D3KpzMTJyPOR/HU6n2Si5QdaXYEsng2xgOs8= cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= @@ -187,22 +184,36 @@ cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xX cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg= cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0= cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M= -cosmossdk.io/api v0.3.1 h1:NNiOclKRR0AOlO4KIqeaG6PS6kswOMhHD0ir0SscNXE= -cosmossdk.io/api v0.3.1/go.mod h1:DfHfMkiNA2Uhy8fj0JJlOCYOBp4eWUUJ1te5zBGNyIw= -cosmossdk.io/core v0.5.1 h1:vQVtFrIYOQJDV3f7rw4pjjVqc1id4+mE0L9hHP66pyI= -cosmossdk.io/core v0.5.1/go.mod h1:KZtwHCLjcFuo0nmDc24Xy6CRNEL9Vl/MeimQ2aC7NLE= +cosmossdk.io/api v0.7.3 h1:V815i8YOwOAQa1rLCsSMjVG5Gnzs02JLq+l7ks8s1jk= +cosmossdk.io/api v0.7.3/go.mod h1:IcxpYS5fMemZGqyYtErK7OqvdM0C8kdW3dq8Q/XIG38= +cosmossdk.io/client/v2 v2.0.0-beta.1 h1:XkHh1lhrLYIT9zKl7cIOXUXg2hdhtjTPBUfqERNA1/Q= +cosmossdk.io/client/v2 v2.0.0-beta.1/go.mod h1:JEUSu9moNZQ4kU3ir1DKD5eU4bllmAexrGWjmb9k8qU= +cosmossdk.io/collections v0.4.0 h1:PFmwj2W8szgpD5nOd8GWH6AbYNi1f2J6akWXJ7P5t9s= +cosmossdk.io/collections v0.4.0/go.mod h1:oa5lUING2dP+gdDquow+QjlF45eL1t4TJDypgGd+tv0= +cosmossdk.io/core v0.11.0 h1:vtIafqUi+1ZNAE/oxLOQQ7Oek2n4S48SWLG8h/+wdbo= +cosmossdk.io/core v0.11.0/go.mod h1:LaTtayWBSoacF5xNzoF8tmLhehqlA9z1SWiPuNC6X1w= cosmossdk.io/depinject v1.0.0-alpha.4 h1:PLNp8ZYAMPTUKyG9IK2hsbciDWqna2z1Wsl98okJopc= cosmossdk.io/depinject v1.0.0-alpha.4/go.mod h1:HeDk7IkR5ckZ3lMGs/o91AVUc7E596vMaOmslGFM3yU= -cosmossdk.io/errors v1.0.0 h1:nxF07lmlBbB8NKQhtJ+sJm6ef5uV1XkvPXG2bUntb04= -cosmossdk.io/errors v1.0.0/go.mod h1:+hJZLuhdDE0pYN8HkOrVNwrIOYvUGnn6+4fjnJs/oV0= -cosmossdk.io/log v1.2.1 h1:Xc1GgTCicniwmMiKwDxUjO4eLhPxoVdI9vtMW8Ti/uk= -cosmossdk.io/log v1.2.1/go.mod h1:GNSCc/6+DhFIj1aLn/j7Id7PaO8DzNylUZoOYBL9+I4= -cosmossdk.io/math v1.1.2 h1:ORZetZCTyWkI5GlZ6CZS28fMHi83ZYf+A2vVnHNzZBM= -cosmossdk.io/math v1.1.2/go.mod h1:l2Gnda87F0su8a/7FEKJfFdJrM0JZRXQaohlgJeyQh0= +cosmossdk.io/errors v1.0.1 h1:bzu+Kcr0kS/1DuPBtUFdWjzLqyUuCiyHjyJB6srBV/0= +cosmossdk.io/errors v1.0.1/go.mod h1:MeelVSZThMi4bEakzhhhE/CKqVv3nOJDA25bIqRDu/U= +cosmossdk.io/log v1.3.1 h1:UZx8nWIkfbbNEWusZqzAx3ZGvu54TZacWib3EzUYmGI= +cosmossdk.io/log v1.3.1/go.mod h1:2/dIomt8mKdk6vl3OWJcPk2be3pGOS8OQaLUM/3/tCM= +cosmossdk.io/math v1.2.0 h1:8gudhTkkD3NxOP2YyyJIYYmt6dQ55ZfJkDOaxXpy7Ig= +cosmossdk.io/math v1.2.0/go.mod h1:l2Gnda87F0su8a/7FEKJfFdJrM0JZRXQaohlgJeyQh0= cosmossdk.io/simapp v0.0.0-20230224204036-a6adb0821462 h1:g8muUHnXL8vhld2Sjilyhb1UQObc+x9GVuDK43TYZns= cosmossdk.io/simapp v0.0.0-20230224204036-a6adb0821462/go.mod h1:4Dd3NLoLYoN90kZ0uyHoTHzVVk9+J0v4HhZRBNTAq2c= -cosmossdk.io/tools/rosetta v0.2.1 h1:ddOMatOH+pbxWbrGJKRAawdBkPYLfKXutK9IETnjYxw= -cosmossdk.io/tools/rosetta v0.2.1/go.mod h1:Pqdc1FdvkNV3LcNIkYWt2RQY6IP1ge6YWZk8MhhO9Hw= +cosmossdk.io/store v1.0.2 h1:lSg5BTvJBHUDwswNNyeh4K/CbqiHER73VU4nDNb8uk0= +cosmossdk.io/store v1.0.2/go.mod h1:EFtENTqVTuWwitGW1VwaBct+yDagk7oG/axBMPH+FXs= +cosmossdk.io/x/circuit v0.1.0 h1:IAej8aRYeuOMritczqTlljbUVHq1E85CpBqaCTwYgXs= +cosmossdk.io/x/circuit v0.1.0/go.mod h1:YDzblVE8+E+urPYQq5kq5foRY/IzhXovSYXb4nwd39w= +cosmossdk.io/x/evidence v0.1.0 h1:J6OEyDl1rbykksdGynzPKG5R/zm6TacwW2fbLTW4nCk= +cosmossdk.io/x/evidence v0.1.0/go.mod h1:hTaiiXsoiJ3InMz1uptgF0BnGqROllAN8mwisOMMsfw= +cosmossdk.io/x/feegrant v0.1.0 h1:c7s3oAq/8/UO0EiN1H5BIjwVntujVTkYs35YPvvrdQk= +cosmossdk.io/x/feegrant v0.1.0/go.mod h1:4r+FsViJRpcZif/yhTn+E0E6OFfg4n0Lx+6cCtnZElU= +cosmossdk.io/x/tx v0.13.0 h1:8lzyOh3zONPpZv2uTcUmsv0WTXy6T1/aCVDCqShmpzU= +cosmossdk.io/x/tx v0.13.0/go.mod h1:CpNQtmoqbXa33/DVxWQNx5Dcnbkv2xGUhL7tYQ5wUsY= +cosmossdk.io/x/upgrade v0.1.0 h1:z1ZZG4UL9ICTNbJDYZ6jOnF9GdEK9wyoEFi4BUScHXE= +cosmossdk.io/x/upgrade v0.1.0/go.mod h1:/6jjNGbiPCNtmA1N+rBtP601sr0g4ZXuj3yC6ClPCGY= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= filippo.io/edwards25519 v1.0.0 h1:0wAIcmJUqRdI8IJ/3eGi5/HwXZWPujYXXlkrQogz0Ek= filippo.io/edwards25519 v1.0.0/go.mod h1:N1IkdkCkiLB6tki+MYJoSx2JTY9NUlxZE7eHn5EwJns= @@ -210,13 +221,13 @@ github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 h1:/vQbFIOMb github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4/go.mod h1:hN7oaIRCjzsZ2dE+yG5k+rsdt3qcwykqK6HVGcKwsw4= github.com/99designs/keyring v1.2.2 h1:pZd3neh/EmUzWONb35LxQfvuY7kiSXAq3HQd97+XBn0= github.com/99designs/keyring v1.2.2/go.mod h1:wes/FrByc8j7lFOAGLGSNEg8f/PaI3cgTBqhFkHUrPk= -github.com/AdaLogics/go-fuzz-headers v0.0.0-20210715213245-6c3934b029d8 h1:V8krnnfGj4pV65YLUm3C0/8bl7V5Nry2Pwvy3ru/wLc= -github.com/AdaLogics/go-fuzz-headers v0.0.0-20210715213245-6c3934b029d8/go.mod h1:CzsSbkDixRphAF5hS6wbMKq0eI6ccJRb7/A0M6JBnwg= -github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8= -github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 h1:bvDV9vkmnHYOMsOr4WLk+Vo07yKIzd94sVoIqshQ4bU= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8= +github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0= +github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= -github.com/BurntSushi/toml v1.3.0 h1:Ws8e5YmnrGEHzZEzg0YvK/7COGYtTC5PbaH9oSSbgfA= -github.com/BurntSushi/toml v1.3.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= +github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8= +github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d h1:nalkkPQcITbvhmL4+C4cKA87NW0tfm3Kl9VXRoPywFg= github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d/go.mod h1:URdX5+vg25ts3aCh8H5IFZybJYKWhJHYMTnf+ULtoC4= @@ -224,28 +235,32 @@ github.com/ChainSafe/go-schnorrkel v1.0.0 h1:3aDA67lAykLaG1y3AOjs88dMxC88PgUuHRr github.com/ChainSafe/go-schnorrkel v1.0.0/go.mod h1:dpzHYVxLZcp8pjlV+O+UR8K0Hp/z7vcchBSbMBEhCw4= github.com/ComposableFi/go-subkey/v2 v2.0.0-tm03420 h1:oknQF/iIhf5lVjbwjsVDzDByupRhga8nhA3NAmwyHDA= github.com/ComposableFi/go-subkey/v2 v2.0.0-tm03420/go.mod h1:KYkiMX5AbOlXXYfxkrYPrRPV6EbVUALTQh5ptUOJzu8= +github.com/DataDog/datadog-go v3.2.0+incompatible h1:qSG2N4FghB1He/r2mFrWKCaL7dXCilEuNEeAn20fdD4= github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= +github.com/DataDog/zstd v1.5.5 h1:oWf5W7GtOLgp6bciQYDmhHHjdhYkALu6S/5Ni9ZgSvQ= +github.com/DataDog/zstd v1.5.5/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= github.com/FactomProject/basen v0.0.0-20150613233007-fe3947df716e h1:ahyvB3q25YnZWly5Gq1ekg6jcmWaGj/vG/MhF4aisoc= github.com/FactomProject/basen v0.0.0-20150613233007-fe3947df716e/go.mod h1:kGUqhHd//musdITWjFvNTHn90WG9bMLBEPQZ17Cmlpw= github.com/FactomProject/btcutilecc v0.0.0-20130527213604-d3a63a5752ec h1:1Qb69mGp/UtRPn422BH4/Y4Q3SLUrD9KHuDkm8iodFc= github.com/FactomProject/btcutilecc v0.0.0-20130527213604-d3a63a5752ec/go.mod h1:CD8UlnlLDiqb36L110uqiP2iSflVjx9g/3U9hCI4q2U= github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= -github.com/Microsoft/go-winio v0.6.0 h1:slsWYD/zyx7lCXoZVlvQrj0hPTM1HI4+v1sIda2yDvg= -github.com/Microsoft/go-winio v0.6.0/go.mod h1:cTAf44im0RAYeL23bpB+fzCyDH2MJiz2BO69KH/soAE= -github.com/Microsoft/hcsshim v0.9.4 h1:mnUj0ivWy6UzbB1uLFqKR6F+ZyiDc7j4iGgHTpO+5+I= -github.com/Microsoft/hcsshim v0.9.4/go.mod h1:7pLA8lDk46WKDWlVsENo92gC0XFa8rbKfyFRBqxEbCc= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/Microsoft/hcsshim v0.11.4 h1:68vKo2VN8DE9AdN4tnkWnmdhqdbpUFM8OF3Airm7fz8= +github.com/Microsoft/hcsshim v0.11.4/go.mod h1:smjE4dvqPX9Zldna+t5FG3rnoHhaB7QYxPRqGcpAD9w= github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw= github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= -github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/OneOfOne/xxhash v1.2.8 h1:31czK/TI9sNkxIKfaUfGlU47BAxQ0ztGgd9vPyqimf8= +github.com/OneOfOne/xxhash v1.2.8/go.mod h1:eZbhyaAYD41SGSSsnmcpxVoRiQ/MPUTjUdIIOT9Um7Q= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= -github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 h1:fLjPD/aNc3UIOA6tDi6QXUemppXK3P9BI7mr2hd6gx8= -github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= +github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= +github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= github.com/StirlingMarketingGroup/go-namecase v1.0.0 h1:2CzaNtCzc4iNHirR+5ru9OzGg8rQp860gqLBFqRI02Y= github.com/StirlingMarketingGroup/go-namecase v1.0.0/go.mod h1:ZsoSKcafcAzuBx+sndbxHu/RjDcDTrEdT4UvhniHfio= -github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o= -github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw= +github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= +github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE= github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= github.com/adlio/schema v1.3.3 h1:oBJn8I02PyTB466pZO1UZEn1TV5XLlifBSyMrmHl/1I= @@ -263,20 +278,17 @@ github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= -github.com/armon/go-metrics v0.4.1 h1:hR91U9KYmb6bLBYLQjyM+3j+rcd/UhE+G78SFnF8gJA= -github.com/armon/go-metrics v0.4.1/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= -github.com/avast/retry-go/v4 v4.3.4 h1:pHLkL7jvCvP317I8Ge+Km2Yhntv3SdkJm7uekkqbKhM= -github.com/avast/retry-go/v4 v4.3.4/go.mod h1:rv+Nla6Vk3/ilU0H51VHddWHiwimzX66yZ0JT6T+UvE= +github.com/avast/retry-go/v4 v4.5.1 h1:AxIx0HGi4VZ3I02jr78j5lZ3M6x1E0Ivxa6b0pUUh7o= +github.com/avast/retry-go/v4 v4.5.1/go.mod h1:/sipNsvNB3RRuT5iNcb6h73nw3IBmXJ/H3XrCQYSOpc= github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go v1.44.122/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo= -github.com/aws/aws-sdk-go v1.44.203 h1:pcsP805b9acL3wUqa4JR2vg1k2wnItkDYNvfmcy6F+U= -github.com/aws/aws-sdk-go v1.44.203/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= +github.com/aws/aws-sdk-go v1.44.312 h1:llrElfzeqG/YOLFFKjg1xNpZCFJ2xraIi3PqSuP+95k= +github.com/aws/aws-sdk-go v1.44.312/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g= -github.com/benbjohnson/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A= -github.com/benbjohnson/clock v1.3.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= @@ -286,22 +298,24 @@ github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 h1:41iFGWnSlI2gVpmOtVTJZNodLdLQLn/KsJqFvXwnd/s= github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= +github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M= -github.com/btcsuite/btcd v0.23.0/go.mod h1:0QJIIN1wwIXF/3G/m87gIwGniDMDQqjVn4SZgnFpsYY= -github.com/btcsuite/btcd v0.23.4 h1:IzV6qqkfwbItOS/sg/aDfPDsjPP8twrCOE2R93hxMlQ= -github.com/btcsuite/btcd v0.23.4/go.mod h1:0QJIIN1wwIXF/3G/m87gIwGniDMDQqjVn4SZgnFpsYY= +github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd h1:js1gPwhcFflTZ7Nzl7WHaOTlTr5hIrR4n1NM4v9n4Kw= +github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A= github.com/btcsuite/btcd/btcec/v2 v2.1.0/go.mod h1:2VzYrv4Gm4apmbVVsSq5bqf1Ec8v56E48Vt0Y/umPgA= github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE= github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U= github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= github.com/btcsuite/btcd/btcutil v1.0.0/go.mod h1:Uoxwv0pqYWhD//tfTiipkxNfdhG9UrLwaeswfjfdF0A= github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUBTwmWH/0Jn8VHE= -github.com/btcsuite/btcd/btcutil v1.1.3 h1:xfbtw8lwpp0G6NwSHb+UE67ryTFHJAiNuipusjXSohQ= -github.com/btcsuite/btcd/btcutil v1.1.3/go.mod h1:UR7dsSJzJUfMmFiiLlIrMq1lS9jh9EdCV7FStZSnpi0= +github.com/btcsuite/btcd/btcutil v1.1.5 h1:+wER79R5670vs/ZusMTF1yTcRYE5GUsFbdjdisflzM8= +github.com/btcsuite/btcd/btcutil v1.1.5/go.mod h1:PSZZ4UitpLBWzxGd5VGOrLnmOjtPP/a6HaFo12zMs00= github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 h1:59Kx4K6lzOW5w6nFlA0v5+lk/6sjybR934QNHSJZPTQ= +github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce h1:YtWJF7RHm2pYCvA5t0RPmAaLUhREsKuKd+SLhxFbFeQ= @@ -313,21 +327,20 @@ github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= -github.com/bufbuild/protocompile v0.4.0 h1:LbFKd2XowZvQ/kajzguUp2DC9UEIQhIq77fZZlaQsNA= -github.com/bufbuild/protocompile v0.4.0/go.mod h1:3v93+mbWn/v3xzN+31nwkJfrEpAUwp+BagBSZWx+TP8= +github.com/bufbuild/protocompile v0.6.0 h1:Uu7WiSQ6Yj9DbkdnOe7U4mNKp58y9WDMKDn28/ZlunY= +github.com/bufbuild/protocompile v0.6.0/go.mod h1:YNP35qEYoYGme7QMtz5SBCoN4kL4g12jTtjuzRNdjpE= github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ= github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4= github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw= -github.com/cenkalti/backoff/v4 v4.1.3 h1:cFAlzYUlVYDysBEH2T5hyJZMh3+5+WCBvSnK6Q8UtC4= -github.com/cenkalti/backoff/v4 v4.1.3/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw= +github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= +github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E= github.com/cheggaaa/pb v1.0.27/go.mod h1:pQciLPpbU0oxA0h+VJYYLxO+XeDQb5pZijXscXHm81s= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM= @@ -338,7 +351,6 @@ github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObk github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04= github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8= -github.com/cilium/ebpf v0.7.0/go.mod h1:/oI2+1shJiTGAMgl6/RgJr36Eo1jzrRcAWbcXO2usCA= github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag= github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I= github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE= @@ -357,86 +369,95 @@ github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWH github.com/cockroachdb/apd/v2 v2.0.2 h1:weh8u7Cneje73dDh+2tEVLUvyBc89iwepWCD8b8034E= github.com/cockroachdb/apd/v2 v2.0.2/go.mod h1:DDxRlzC2lo3/vSlmSoS7JkqbbrARPuFOGr0B9pvN3Gw= github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8= -github.com/cockroachdb/errors v1.10.0 h1:lfxS8zZz1+OjtV4MtNWgboi/W5tyLEB6VQZBXN+0VUU= -github.com/cockroachdb/errors v1.10.0/go.mod h1:lknhIsEVQ9Ss/qKDBQS/UqFSvPQjOwNq2qyKAxtHRqE= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= +github.com/cockroachdb/errors v1.11.1 h1:xSEW75zKaKCWzR3OfxXUxgrk/NtT4G1MiOv5lWZazG8= +github.com/cockroachdb/errors v1.11.1/go.mod h1:8MUxA3Gi6b25tYlFEBGLf+D8aISL+M4MIpiWMSNRfxw= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/pebble v1.1.0 h1:pcFh8CdCIt2kmEpK0OIatq67Ln9uGDYY3d5XnE0LJG4= +github.com/cockroachdb/pebble v1.1.0/go.mod h1:sEHm5NOXxyiAoKWhoFxT8xMgd/f3RA6qUqQ1BXKrh2E= github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI= -github.com/coinbase/rosetta-sdk-go/types v1.0.0 h1:jpVIwLcPoOeCR6o1tU+Xv7r5bMONNbHU7MuEHboiFuA= -github.com/coinbase/rosetta-sdk-go/types v1.0.0/go.mod h1:eq7W2TMRH22GTW0N0beDnN931DW0/WOI1R2sdHNHG4c= -github.com/cometbft/cometbft v0.37.2 h1:XB0yyHGT0lwmJlFmM4+rsRnczPlHoAKFX6K8Zgc2/Jc= -github.com/cometbft/cometbft v0.37.2/go.mod h1:Y2MMMN//O5K4YKd8ze4r9jmk4Y7h0ajqILXbH5JQFVs= -github.com/cometbft/cometbft-db v0.8.0 h1:vUMDaH3ApkX8m0KZvOFFy9b5DZHBAjsnEuo9AKVZpjo= -github.com/cometbft/cometbft-db v0.8.0/go.mod h1:6ASCP4pfhmrCBpfk01/9E1SI29nD3HfVHrY4PG8x5c0= -github.com/confio/ics23/go v0.9.0 h1:cWs+wdbS2KRPZezoaaj+qBleXgUk5WOQFMP3CQFGTr4= -github.com/confio/ics23/go v0.9.0/go.mod h1:4LPZ2NYqnYIVRklaozjNR1FScgDJ2s5Xrp+e/mYVRak= -github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U= -github.com/containerd/containerd v1.6.8 h1:h4dOFDwzHmqFEP754PgfgTeVXFnLiRc6kiqC7tplDJs= -github.com/containerd/containerd v1.6.8/go.mod h1:By6p5KqPK0/7/CgO/A6t/Gz+CUYUu2zf1hUaaymVXB0= -github.com/containerd/continuity v0.3.0 h1:nisirsYROK15TAMVukJOUyGJjz4BNQJBVsNvAXZJ/eg= -github.com/containerd/continuity v0.3.0/go.mod h1:wJEAIwKOm/pBZuBd0JmeTvnLquTB1Ag8espWhkykbPM= +github.com/cometbft/cometbft v0.38.5 h1:4lOcK5VTPrfbLOhNHmPYe6c7eDXHtBdMCQuKbAfFJdU= +github.com/cometbft/cometbft v0.38.5/go.mod h1:0tqKin+KQs8zDwzYD8rPHzSBIDNPuB4NrwwGDNb/hUg= +github.com/cometbft/cometbft-db v0.9.1 h1:MIhVX5ja5bXNHF8EYrThkG9F7r9kSfv8BX4LWaxWJ4M= +github.com/cometbft/cometbft-db v0.9.1/go.mod h1:iliyWaoV0mRwBJoizElCwwRA9Tf7jZJOURcRZF9m60U= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= +github.com/containerd/containerd v1.7.11 h1:lfGKw3eU35sjV0aG2eYZTiwFEY1pCzxdzicHP3SZILw= +github.com/containerd/containerd v1.7.11/go.mod h1:5UluHxHTX2rdvYuZ5OJTC5m/KJNs0Zs9wVoJm9zf5ZE= +github.com/containerd/continuity v0.4.2 h1:v3y/4Yz5jwnvqPKJJ+7Wf93fyWoCB3F5EclWG023MDM= +github.com/containerd/continuity v0.4.2/go.mod h1:F6PTNCKepoxEaXLQp3wDAjygEnImnZ/7o4JzpodfroQ= github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= -github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/cosmos/btcutil v1.0.5 h1:t+ZFcX77LpKtDBhjucvnOH8C2l2ioGsBNEQ3jef8xFk= github.com/cosmos/btcutil v1.0.5/go.mod h1:IyB7iuqZMJlthe2tkIFL33xPyzbFYP0XVdS8P5lUPis= -github.com/cosmos/cosmos-proto v1.0.0-beta.2 h1:X3OKvWgK9Gsejo0F1qs5l8Qn6xJV/AzgIWR2wZ8Nua8= -github.com/cosmos/cosmos-proto v1.0.0-beta.2/go.mod h1:+XRCLJ14pr5HFEHIUcn51IKXD1Fy3rkEQqt4WqmN4V0= -github.com/cosmos/cosmos-sdk v0.47.5 h1:n1+WjP/VM/gAEOx3TqU2/Ny734rj/MX1kpUnn7zVJP8= -github.com/cosmos/cosmos-sdk v0.47.5/go.mod h1:EHwCeN9IXonsjKcjpS12MqeStdZvIdxt3VYXhus3G3c= +github.com/cosmos/cosmos-db v1.0.0 h1:EVcQZ+qYag7W6uorBKFPvX6gRjw6Uq2hIh4hCWjuQ0E= +github.com/cosmos/cosmos-db v1.0.0/go.mod h1:iBvi1TtqaedwLdcrZVYRSSCb6eSy61NLj4UNmdIgs0U= +github.com/cosmos/cosmos-proto v1.0.0-beta.4 h1:aEL7tU/rLOmxZQ9z4i7mzxcLbSCY48OdY7lIWTLG7oU= +github.com/cosmos/cosmos-proto v1.0.0-beta.4/go.mod h1:oeB+FyVzG3XrQJbJng0EnV8Vljfk9XvTIpGILNU/9Co= +github.com/cosmos/cosmos-sdk v0.50.4 h1:hQT5/+Z1XXNF7skaPq0i247Ts2dzzqg/j2WO/BPHSto= +github.com/cosmos/cosmos-sdk v0.50.4/go.mod h1:UbShFs6P8Ly29xxJvkNGaNaL/UGj5a686NRtb1Cqra0= github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y= github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY= github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= github.com/cosmos/gogogateway v1.2.0 h1:Ae/OivNhp8DqBi/sh2A8a1D0y638GpL3tkmLQAiKxTE= github.com/cosmos/gogogateway v1.2.0/go.mod h1:iQpLkGWxYcnCdz5iAdLcRBSw3h7NXeOkZ4GUkT+tbFI= github.com/cosmos/gogoproto v1.4.2/go.mod h1:cLxOsn1ljAHSV527CHOtaIP91kK6cCrZETRBrkzItWU= -github.com/cosmos/gogoproto v1.4.10 h1:QH/yT8X+c0F4ZDacDv3z+xE3WU1P1Z3wQoLMBRJoKuI= -github.com/cosmos/gogoproto v1.4.10/go.mod h1:3aAZzeRWpAwr+SS/LLkICX2/kDFyaYVzckBDzygIxek= -github.com/cosmos/iavl v0.20.0 h1:fTVznVlepH0KK8NyKq8w+U7c2L6jofa27aFX6YGlm38= -github.com/cosmos/iavl v0.20.0/go.mod h1:WO7FyvaZJoH65+HFOsDir7xU9FWk2w9cHXNW1XHcl7A= -github.com/cosmos/ibc-go/modules/capability v1.0.0-rc1 h1:BvSKnPFKxL+TTSLxGKwJN4x0ndCZj0yfXhSvmsQztSA= -github.com/cosmos/ibc-go/modules/capability v1.0.0-rc1/go.mod h1:A+CxAQdn2j6ihDTbClpEEBdHthWgAUAcHbRAQPY8sl4= -github.com/cosmos/ibc-go/v7 v7.3.0 h1:QtGeVMi/3JeLWuvEuC60sBHpAF40Oenx/y+bP8+wRRw= -github.com/cosmos/ibc-go/v7 v7.3.0/go.mod h1:mUmaHFXpXrEdcxfdXyau+utZf14pGKVUiXwYftRZZfQ= +github.com/cosmos/gogoproto v1.4.11 h1:LZcMHrx4FjUgrqQSWeaGC1v/TeuVFqSLa43CC6aWR2g= +github.com/cosmos/gogoproto v1.4.11/go.mod h1:/g39Mh8m17X8Q/GDEs5zYTSNaNnInBSohtaxzQnYq1Y= +github.com/cosmos/iavl v1.0.1 h1:D+mYbcRO2wptYzOM1Hxl9cpmmHU1ZEt9T2Wv5nZTeUw= +github.com/cosmos/iavl v1.0.1/go.mod h1:8xIUkgVvwvVrBu81scdPty+/Dx9GqwHnAvXz4cwF7RY= +github.com/cosmos/ibc-go/modules/capability v1.0.0 h1:r/l++byFtn7jHYa09zlAdSeevo8ci1mVZNO9+V0xsLE= +github.com/cosmos/ibc-go/modules/capability v1.0.0/go.mod h1:D81ZxzjZAe0ZO5ambnvn1qedsFQ8lOwtqicG6liLBco= +github.com/cosmos/ibc-go/v8 v8.0.0 h1:QKipnr/NGwc+9L7NZipURvmSIu+nw9jOIWTJuDBqOhg= +github.com/cosmos/ibc-go/v8 v8.0.0/go.mod h1:C6IiJom0F3cIQCD5fKwVPDrDK9j/xTu563AWuOmXois= github.com/cosmos/ics23/go v0.10.0 h1:iXqLLgp2Lp+EdpIuwXTYIQU+AiHj9mOC2X9ab++bZDM= github.com/cosmos/ics23/go v0.10.0/go.mod h1:ZfJSmng/TBNTBkFemHHHj5YY7VAU/MBU980F4VU1NG0= -github.com/cosmos/ledger-cosmos-go v0.12.2 h1:/XYaBlE2BJxtvpkHiBm97gFGSGmYGKunKyF3nNqAXZA= -github.com/cosmos/ledger-cosmos-go v0.12.2/go.mod h1:ZcqYgnfNJ6lAXe4HPtWgarNEY+B74i+2/8MhZw4ziiI= -github.com/cosmos/rosetta-sdk-go v0.10.0 h1:E5RhTruuoA7KTIXUcMicL76cffyeoyvNybzUGSKFTcM= -github.com/cosmos/rosetta-sdk-go v0.10.0/go.mod h1:SImAZkb96YbwvoRkzSMQB6noNJXFgWl/ENIznEoYQI4= +github.com/cosmos/ledger-cosmos-go v0.13.3 h1:7ehuBGuyIytsXbd4MP43mLeoN2LTOEnk5nvue4rK+yM= +github.com/cosmos/ledger-cosmos-go v0.13.3/go.mod h1:HENcEP+VtahZFw38HZ3+LS3Iv5XV6svsnkk9vdJtLr8= github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= -github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/creachadair/taskgroup v0.4.2 h1:jsBLdAJE42asreGss2xZGZ8fJra7WtwnHWeJFxv2Li8= -github.com/creachadair/taskgroup v0.4.2/go.mod h1:qiXUOSrbwAY3u0JPGTzObbE3yf9hcXHDKBZ2ZjpCbgM= +github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= +github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/cyphar/filepath-securejoin v0.2.3/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4= github.com/danieljoos/wincred v1.1.2 h1:QLdCxFs1/Yl4zduvBdcHB8goaYk9RARS2SgLLRuAyr0= github.com/danieljoos/wincred v1.1.2/go.mod h1:GijpziifJoIBfYh+S7BbkdUTU4LfM+QnGqR5Vl2tAx0= github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4= github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo= +github.com/deckarep/golang-set/v2 v2.1.0 h1:g47V4Or+DUdzbs8FxCCmgb6VYd+ptPAngjM6dtGktsI= +github.com/deckarep/golang-set/v2 v2.1.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= github.com/decred/base58 v1.0.4 h1:QJC6B0E0rXOPA8U/kw2rP+qiRJsUaE2Er+pYb3siUeA= github.com/decred/base58 v1.0.4/go.mod h1:jJswKPEdvpFpvf7dsDvFZyLT22xZ9lWqEByX38oGd9E= github.com/decred/dcrd/chaincfg/chainhash v1.0.2 h1:rt5Vlq/jM3ZawwiacWjPa+smINyLRN07EO0cNBV6DGU= github.com/decred/dcrd/chaincfg/chainhash v1.0.2/go.mod h1:BpbrGgrPTr3YJYRN3Bm+D9NuaFd+zGyNeIKgrhCXK60= -github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= -github.com/decred/dcrd/dcrec/secp256k1/v2 v2.0.0 h1:3GIJYXQDAKpLEFriGFN8SbSffak10UXHGdIcFaMPykY= -github.com/decred/dcrd/dcrec/secp256k1/v2 v2.0.0/go.mod h1:3s92l0paYkZoIHuj4X93Teg/HB7eGM9x/zokGw+u4mY= +github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y= +github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= +github.com/decred/dcrd/dcrec/secp256k1/v2 v2.0.1 h1:18HurQ6DfHeNvwIjvOmrgr44bPdtVaQAe/WWwHg9goM= +github.com/decred/dcrd/dcrec/secp256k1/v2 v2.0.1/go.mod h1:XmyzkaXBy7ZvHdrTAlXAjpog8qKSAWa3ze7yqzWmgmc= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 h1:HbphB4TFFXpv7MNrT52FGrrgVXF1owhMVTHFZIlnvd4= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0/go.mod h1:DZGJHZMqrU4JJqFAWUS2UO1+lbSKsdiOoYi9Zzey7Fc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218= github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f h1:U5y3Y5UE0w7amNe7Z5G/twsBW0KEalRQXZzf8ufSh9I= github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f/go.mod h1:xH/i4TFMt8koVQZ6WFms69WAsDWr2XsYL3Hkl7jkoLE= @@ -451,23 +472,24 @@ github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WA github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/docker/distribution v2.8.2+incompatible h1:T3de5rq0dB1j30rp0sA2rER+m322EBzniBPB6ZIzuh8= github.com/docker/distribution v2.8.2+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w= -github.com/docker/docker v24.0.1+incompatible h1:NxN81beIxDlUaVt46iUQrYHD9/W3u9EGl52r86O/IGw= -github.com/docker/docker v24.0.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/docker v24.0.7+incompatible h1:Wo6l37AuwP3JaMnZa226lzVXGA3F9Ig1seQen0cKYlM= +github.com/docker/docker v24.0.7+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKohAFqRJQ= github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec= -github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/dvsekhvalnov/jose2go v1.5.0 h1:3j8ya4Z4kMCwT5nXIKFSV84YS+HdqSSO0VsTQxaLAeM= -github.com/dvsekhvalnov/jose2go v1.5.0/go.mod h1:QsHjhyTlD/lAVqn/NSbVZmSCGeDehTB/mPZadG+mhXU= +github.com/dvsekhvalnov/jose2go v1.6.0 h1:Y9gnSnP4qEI0+/uQkHvFXeD2PLPJeXEL+ySMEA2EjTY= +github.com/dvsekhvalnov/jose2go v1.6.0/go.mod h1:QsHjhyTlD/lAVqn/NSbVZmSCGeDehTB/mPZadG+mhXU= github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs= github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= +github.com/emicklei/dot v1.6.1 h1:ujpDlBkkwgWUY+qPId5IwapRW/xEoligRSYjioR6DFI= +github.com/emicklei/dot v1.6.1/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= @@ -479,26 +501,31 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.m github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/ethereum/go-ethereum v1.10.26 h1:i/7d9RBBwiXCEuyduBQzJw/mKmnvzsN14jqBmytw72s= -github.com/ethereum/go-ethereum v1.10.26/go.mod h1:EYFyF19u3ezGLD4RqOkLq+ZCXzYbLoNDdZlMt7kyKFg= +github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= +github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.13.14 h1:EwiY3FZP94derMCIam1iW4HFVrSgIcpsu0HwTQtm6CQ= +github.com/ethereum/go-ethereum v1.13.14/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/felixge/httpsnoop v1.0.2 h1:+nS9g82KMXccJ/wp0zyRW9ZBHFETmMGtkk+2CTTrW4o= -github.com/felixge/httpsnoop v1.0.2/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= +github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4= github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= -github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k= -github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= -github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU= -github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= -github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= -github.com/getsentry/sentry-go v0.23.0 h1:dn+QRCeJv4pPt9OjVXiMcGIBIefaTJPw/h0bZWO05nE= -github.com/getsentry/sentry-go v0.23.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= +github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= +github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= +github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= @@ -515,6 +542,7 @@ github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2 github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o= github.com/go-kit/kit v0.12.0 h1:e4o3o3IsBfAKQh5Qbbiqyfu97Ku7jrO/JbohvztANh4= github.com/go-kit/kit v0.12.0/go.mod h1:lHd+EkCZPIwYItmGDDRdhinkzX2A1sj+M9biaEaizzs= +github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU= github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= @@ -522,8 +550,8 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4= github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= -github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= -github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= github.com/go-playground/locales v0.14.0 h1:u50s323jtVGugKlcYeyzC0etD1HifMjqmJqb8WugfUU= @@ -536,21 +564,19 @@ github.com/go-playground/validator/v10 v10.11.1 h1:prmOlTVv+YjZjmRmNSF3VmspqJIxJ github.com/go-playground/validator/v10 v10.11.1/go.mod h1:i+3WkQ1FvaUjjxh1kSvIA4dMGDBiPU55YFDl0WbKdWU= github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= -github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw= -github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4= github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0= github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo= github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8= github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw= -github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo= github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM= -github.com/goccy/go-json v0.9.11 h1:/pAaQDLHEoCq/5FFmSKBswWmK6H0e8g4159Kc/X/nqk= -github.com/goccy/go-json v0.9.11/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/gobwas/ws v1.2.1 h1:F2aeBZrm2NDsc7vbovKrWSogd4wvfAxg0FQ89/iqOTk= +github.com/gobwas/ws v1.2.1/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY= +github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= +github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+Hoeu/iUR3ruzNvZ+yQfO03a0= github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= -github.com/godbus/dbus/v5 v5.0.6/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= @@ -558,8 +584,8 @@ github.com/gogo/googleapis v1.4.1-0.20201022092350-68b0159b7869/go.mod h1:5YRNX2 github.com/gogo/googleapis v1.4.1 h1:1Yx4Myt7BxzvUr5ldGSbwYiZG6t9wGBZ+8/fX3Wvtq0= github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/glog v1.1.0 h1:/d3pCKDPWNnvIWe0vVUpNP32qc8U3PDVxySP/y360qE= -github.com/golang/glog v1.1.0/go.mod h1:pfYeQZ3JWZoXTV5sFc986z3HTpwQs9At6P4ImfuP3NQ= +github.com/golang/glog v1.2.0 h1:uCdmnmatrKCgMBlM4rMuJZWOkPDqdbZPnrMXDY4gI68= +github.com/golang/glog v1.2.0/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -598,8 +624,9 @@ github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.1.2 h1:xf4v41cLI2Z6FxbKm+8Bu+m8ifhj15JuZ9sa0jZCMUU= @@ -618,8 +645,9 @@ github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-github/v43 v43.0.0 h1:y+GL7LIsAIF2NZlJ46ZoC/D1W1ivZasT0lnWHMYPZ+U= github.com/google/go-github/v43 v43.0.0/go.mod h1:ZkTvvmCXBvsfPpTHXnH/d2hP9Y0cTbvN9kr5xqyXOIc= github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= @@ -646,27 +674,28 @@ github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hf github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ= -github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo= +github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b h1:h9U78+dx9a4BKdQkBBos92HalKpaGKHrp+3Uo6yTodo= +github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/google/s2a-go v0.1.4 h1:1kZ/sQM3srePvKs3tXAvQzo66XfcReoqFpIpIccE7Oc= -github.com/google/s2a-go v0.1.4/go.mod h1:Ej+mSEMGRnqRzjc7VtF+jdBwYG5fuJfiZ8ELkjEwM0A= +github.com/google/s2a-go v0.1.7 h1:60BLSyTrOV4/haCDW4zb1guZItoSq8foHCXrAnjBo/o= +github.com/google/s2a-go v0.1.7/go.mod h1:50CgR4k1jNlWBu4UfS4AcfhVe1r6pdZPygJ3R8F0Qdw= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= +github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg= -github.com/googleapis/enterprise-certificate-proxy v0.2.3 h1:yk9/cqRKtT9wXZSsRH9aurXEpJX+U6FLtpYTdC3R06k= -github.com/googleapis/enterprise-certificate-proxy v0.2.3/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs= +github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= @@ -676,26 +705,26 @@ github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99 github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= -github.com/googleapis/gax-go/v2 v2.11.0 h1:9V9PWXEsWnPpQhu/PeQIkS4eGzMlTLGgt80cUUI8Ki4= -github.com/googleapis/gax-go/v2 v2.11.0/go.mod h1:DxmR61SGKkGLa2xigwuZIQpkCI2S5iydzRfb3peWZJI= +github.com/googleapis/gax-go/v2 v2.12.0 h1:A+gCJKdRfqXkr+BIRGtZLibNXf0m1f9E4HG56etFpas= +github.com/googleapis/gax-go/v2 v2.12.0/go.mod h1:y+aIqrI5eb1YGMVJfuV3185Ts/D7qKpsEkdD5+I6QGU= github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= -github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg= -github.com/gorilla/handlers v1.5.1 h1:9lRY6j8DEeeBT10CvO9hGW0gmky0BprnvDI5vfhUHH4= -github.com/gorilla/handlers v1.5.1/go.mod h1:t8XrUpc4KVXb7HGyJ4/cEnwQiaxrX/hz1Zv/4g96P1Q= +github.com/gorilla/handlers v1.5.2 h1:cLTUSsNkgcwhgRqvCNmdbRWG0A3N4F+M2nWKdScwyEE= +github.com/gorilla/handlers v1.5.2/go.mod h1:dX+xVpaxdSw+q0Qek8SSsl3dfMk3jNddUkMzo0GtH0w= github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= -github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI= -github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= +github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= +github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY= +github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= github.com/grpc-ecosystem/go-grpc-middleware v1.2.2/go.mod h1:EaizFBKfUKtMIF5iaDEhniwNedqGo9FuLFzppDr3uwI= -github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw= -github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= +github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI= +github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8= github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= @@ -714,13 +743,19 @@ github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtng github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= -github.com/hashicorp/go-getter v1.7.1 h1:SWiSWN/42qdpR0MdhaOc/bLR48PLuP1ZQtYLRlM69uY= -github.com/hashicorp/go-getter v1.7.1/go.mod h1:W7TalhMmbPmsSMdNjD0ZskARur/9GJ17cfHTRtXV744= +github.com/hashicorp/go-getter v1.7.2 h1:uJDtyXwEfalmp1PqdxuhZqrNkUyClZAhVeZYTArbqkg= +github.com/hashicorp/go-getter v1.7.2/go.mod h1:W7TalhMmbPmsSMdNjD0ZskARur/9GJ17cfHTRtXV744= +github.com/hashicorp/go-hclog v1.5.0 h1:bI2ocEMgcVlz55Oj1xZNBsVi900c7II+fWDyV9o+13c= +github.com/hashicorp/go-hclog v1.5.0/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M= github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc= github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= +github.com/hashicorp/go-metrics v0.5.1 h1:rfPwUqFU6uZXNvGl4hzjY8LEBsqFVU4si1H9/Hqck/U= +github.com/hashicorp/go-metrics v0.5.1/go.mod h1:KEjodfebIOuBYSAe/bHTm+HChmKSxAOXPBieMLYozDE= github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-plugin v1.5.2 h1:aWv8eimFqWlsEiMrYZdPYl+FdHaBJSN4AWwGWfT1G2Y= +github.com/hashicorp/go-plugin v1.5.2/go.mod h1:w1sAEES3g3PuV/RzUrgow20W2uErMly84hhD3um1WL4= github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs= github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo= @@ -728,34 +763,39 @@ github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoD github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= -github.com/hashicorp/go-uuid v1.0.1 h1:fv1ep09latC32wFoVwnqcnKJGnMSdBanPczbHAYm1BE= github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-uuid v1.0.2 h1:cfejS+Tpcp13yd5nYHWDI6qVCny6wyX2Mt5SGur2IGE= +github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/go-version v1.6.0 h1:feTTfFNnjP967rlCxM/I9g701jU+RN74YKx2mOkIeek= github.com/hashicorp/go-version v1.6.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs= -github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c= +github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= +github.com/hashicorp/yamux v0.1.1 h1:yrQxtgseBDrq9Y652vSRDvsKCJKOUD+GzTS4Y0Y8pvE= +github.com/hashicorp/yamux v0.1.1/go.mod h1:CtWFDAQgb7dxtzFs4tWbplKIe2jSi3+5vKbgIO0SLnQ= github.com/hdevalence/ed25519consensus v0.1.0 h1:jtBwzzcHuTmFrQN6xQZn6CQEO/V9f7HsjsjeEZ6auqU= github.com/hdevalence/ed25519consensus v0.1.0/go.mod h1:w3BHWjwJbFU29IRHL1Iqkw3sus+7FctEyM4RqDxYNzo= github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= -github.com/holiman/uint256 v1.2.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM= -github.com/holiman/uint256 v1.2.0/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw= +github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= +github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/huandu/go-assert v1.1.5 h1:fjemmA7sSfYHJD7CUqs9qTwwfdNAx7/j2/ZlHXzNB3c= github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U= github.com/huandu/skiplist v1.2.0 h1:gox56QD77HzSC0w+Ws3MH3iie755GBJU1OER3h5VsYw= github.com/huandu/skiplist v1.2.0/go.mod h1:7v3iFjLcSAzO4fN5B8dvebvo/qsfumiLiDXMrPiHF9w= github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg= +github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI= +github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/icza/dyno v0.0.0-20220812133438-f0b6f8a18845 h1:H+uM0Bv88eur3ZSsd2NGKg3YIiuXxwxtlN7HjE66UTU= @@ -766,12 +806,12 @@ github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANyt github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= -github.com/ipfs/go-cid v0.2.0 h1:01JTiihFq9en9Vz0lc0VDWvZe/uBonGpzo4THP0vcQ0= -github.com/ipfs/go-cid v0.2.0/go.mod h1:P+HXFDF4CVhaVayiEb4wkAy7zBHxBwsJyt0Y5U6MLro= +github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= +github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= -github.com/jhump/protoreflect v1.15.1 h1:HUMERORf3I3ZdX05WaQ6MIpd/NJ434hTp5YiKgfCL6c= -github.com/jhump/protoreflect v1.15.1/go.mod h1:jD/2GMKKE6OqX8qTjhADU1e6DShO+gavG9e0Q693nKo= +github.com/jhump/protoreflect v1.15.3 h1:6SFRuqU45u9hIZPJAoZ8c28T3nK64BNdp9w6jFonzls= +github.com/jhump/protoreflect v1.15.3/go.mod h1:4ORHmSBmlCW8fh3xHmJMGyul1zNqZK4Elxc8qKP+p1k= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= @@ -805,24 +845,24 @@ github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYs github.com/klauspost/compress v1.11.7/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs= github.com/klauspost/compress v1.12.3/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg= github.com/klauspost/compress v1.15.11/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM= -github.com/klauspost/compress v1.16.3 h1:XuJt9zzcnaz6a16/OU53ZjWp/v7/42WcR5t2a0PcNQY= -github.com/klauspost/compress v1.16.3/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= -github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= -github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= -github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU= -github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= +github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI= +github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg= +github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= +github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w= github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY= @@ -830,14 +870,12 @@ github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw= github.com/lib/pq v1.10.7/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8= github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg= -github.com/libp2p/go-libp2p v0.22.0 h1:2Tce0kHOp5zASFKJbNzRElvh0iZwdtG5uZheNW8chIw= -github.com/libp2p/go-libp2p v0.22.0/go.mod h1:UDolmweypBSjQb2f7xutPnwZ/fxioLbMBxSjRksxxU4= -github.com/libp2p/go-openssl v0.1.0 h1:LBkKEcUv6vtZIQLVTegAil8jbNpJErQ9AnT+bWV+Ooo= -github.com/libp2p/go-openssl v0.1.0/go.mod h1:OiOxwPpL3n4xlenjx2h7AwSGaFSC/KZvf6gNdOBQMtc= +github.com/libp2p/go-libp2p v0.31.0 h1:LFShhP8F6xthWiBBq3euxbKjZsoRajVEyBS9snfHxYg= +github.com/libp2p/go-libp2p v0.31.0/go.mod h1:W/FEK1c/t04PbRH3fA9i5oucu5YcgrG0JVoBWT1B7Eg= github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM= github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4= -github.com/linxGnu/grocksdb v1.7.16 h1:Q2co1xrpdkr5Hx3Fp+f+f7fRGhQFQhvi/+226dtLmA8= -github.com/linxGnu/grocksdb v1.7.16/go.mod h1:JkS7pl5qWpGpuVb3bPqTz8nC12X3YtPZT+Xq7+QfQo4= +github.com/linxGnu/grocksdb v1.8.12 h1:1/pCztQUOa3BX/1gR3jSZDoaKFpeHFvQ1XrqZpSvZVo= +github.com/linxGnu/grocksdb v1.8.12/go.mod h1:xZCIb5Muw+nhbDK4Y5UJuOrin5MceOuiXkVUR7vp4WY= github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= @@ -845,6 +883,7 @@ github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3v github.com/manifoldco/promptui v0.9.0 h1:3V4HzJk1TtXW1MTZMP7mdlwbBpIinw3HztaIlYthEiA= github.com/manifoldco/promptui v0.9.0/go.mod h1:ka04sppxSGFAtxX0qhlYQjISsg9mR4GWtQEhdbn6Pgg= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= @@ -853,10 +892,9 @@ github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNx github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-pointer v0.0.1 h1:n+XhsuGeVO6MEAp7xyEukFINEa+Quek5psIR/ylA6o0= -github.com/mattn/go-pointer v0.0.1/go.mod h1:2zXcozF6qYGgmsG+SeTZz3oAbFLdD3OWqnUbNvJZAlc= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU= @@ -864,18 +902,16 @@ github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y= github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= -github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= -github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= github.com/mimoo/StrobeGo v0.0.0-20181016162300-f8f6d4d2b643/go.mod h1:43+3pMjjKimDBf5Kr4ZFNGbLql1zKkbImw+fZbw3geM= github.com/mimoo/StrobeGo v0.0.0-20220103164710-9a04d6ca976b h1:QrHweqAtyJ9EwCaGHBu1fghwxIPiopAHV06JlXrMHjk= github.com/mimoo/StrobeGo v0.0.0-20220103164710-9a04d6ca976b/go.mod h1:xxLb2ip6sSUts3g1irPVHyk/DGslwQsNOo9I7smJfNU= github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g= github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY= -github.com/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g= -github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM= -github.com/misko9/go-substrate-rpc-client/v4 v4.0.0-20230413215336-5bd2aea337ae h1:ZYbJh4TLwfSuSQe6DT/1982SfNNBcmvzrX5FycfSrmo= -github.com/misko9/go-substrate-rpc-client/v4 v4.0.0-20230413215336-5bd2aea337ae/go.mod h1:XexEkZgpnQ3sqUYz84DFoVUcDake6G/tYHrwdbdERhM= +github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= +github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= +github.com/misko9/go-substrate-rpc-client/v4 v4.0.0-20230913220906-b988ea7da0c2 h1:G/cVeTAbB9S/6FSWWqpFV0v49hiuHLbJPu9hTZ0UR2A= +github.com/misko9/go-substrate-rpc-client/v4 v4.0.0-20230913220906-b988ea7da0c2/go.mod h1:Q5BxOd9FxJqYp4vCiLGVdetecPcWTmUQIu0bRigYosU= github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= @@ -889,15 +925,17 @@ github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:F github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/moby/moby v24.0.2+incompatible h1:yH+5dRHH1x3XRKzl1THA2aGTy6CHYnkt5N924ADMax8= -github.com/moby/moby v24.0.2+incompatible/go.mod h1:fDXVQ6+S340veQPv35CzDahGBmHsiclFwfEygB/TWMc= +github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= +github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= +github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= +github.com/moby/moby v24.0.9+incompatible h1:Z/hFbZJqC5Fmuf6jesMLdHU71CMAgdiSJ1ZYey+bFmg= +github.com/moby/moby v24.0.9+incompatible/go.mod h1:fDXVQ6+S340veQPv35CzDahGBmHsiclFwfEygB/TWMc= github.com/moby/patternmatcher v0.5.0 h1:YCZgJOeULcxLw1Q+sVR636pmS7sPEn1Qo2iAN6M7DBo= github.com/moby/patternmatcher v0.5.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc= -github.com/moby/sys/mountinfo v0.5.0/go.mod h1:3bMD3Rg+zkqx8MRYPi7Pyb0Ie97QEBmdxbhnCLlSvSU= github.com/moby/sys/sequential v0.5.0 h1:OPvI35Lzn9K04PBbCLW0g4LcFAJgHsvXsRyewg5lXtc= github.com/moby/sys/sequential v0.5.0/go.mod h1:tH2cOOs5V9MlPiXcQzRC+eEyab644PWKGRYaaV5ZZlo= -github.com/moby/term v0.0.0-20220808134915-39b0c02b01ae h1:O4SWKdcHVCvYqyDV+9CJA1fcDN2L11Bule0iFy3YlAI= -github.com/moby/term v0.0.0-20220808134915-39b0c02b01ae/go.mod h1:E2VnQOmVuvZB6UYnnDB0qG5Nq/1tD9acaOpo6xmt0Kw= +github.com/moby/term v0.0.0-20221205130635-1aeaba878587 h1:HfkjXDfhgVaN5rmueG8cL8KKeFNecRCXFhaJ2qZ5SKA= +github.com/moby/term v0.0.0-20221205130635-1aeaba878587/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= @@ -909,23 +947,22 @@ github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= -github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ= github.com/mtibben/percent v0.2.1 h1:5gssi8Nqo8QU/r2pynCm+hBQHpkB/uNK7BJCFogWdzs= github.com/mtibben/percent v0.2.1/go.mod h1:KG9uO+SZkUp+VkRHsCdYQV3XSZrrSpR3O9ibNBTZrns= -github.com/multiformats/go-base32 v0.0.4 h1:+qMh4a2f37b4xTNs6mqitDinryCI+tfO2dRVMN9mjSE= -github.com/multiformats/go-base32 v0.0.4/go.mod h1:jNLFzjPZtp3aIARHbJRZIaPuspdH0J6q39uUM5pnABM= -github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4= -github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM= -github.com/multiformats/go-multiaddr v0.6.0 h1:qMnoOPj2s8xxPU5kZ57Cqdr0hHhARz7mFsPMIiYNqzg= -github.com/multiformats/go-multiaddr v0.6.0/go.mod h1:F4IpaKZuPP360tOMn2Tpyu0At8w23aRyVqeK0DbFeGM= -github.com/multiformats/go-multibase v0.1.1 h1:3ASCDsuLX8+j4kx58qnJ4YFq/JWTJpCyDW27ztsVTOI= -github.com/multiformats/go-multibase v0.1.1/go.mod h1:ZEjHE+IsUrgp5mhlEAYjMtZwK1k4haNkcaPg9aoe1a8= -github.com/multiformats/go-multicodec v0.5.0 h1:EgU6cBe/D7WRwQb1KmnBvU7lrcFGMggZVTPtOW9dDHs= -github.com/multiformats/go-multicodec v0.5.0/go.mod h1:DiY2HFaEp5EhEXb/iYzVAunmyX/aSFMxq2KMKfWEues= -github.com/multiformats/go-multihash v0.2.1 h1:aem8ZT0VA2nCHHk7bPJ1BjUbHNciqZC/d16Vve9l108= -github.com/multiformats/go-multihash v0.2.1/go.mod h1:WxoMcYG85AZVQUyRyo9s4wULvW5qrI9vb2Lt6evduFc= -github.com/multiformats/go-varint v0.0.6 h1:gk85QWKxh3TazbLxED/NlDVv8+q+ReFJk7Y2W/KhfNY= -github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= +github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE= +github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI= +github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0= +github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4= +github.com/multiformats/go-multiaddr v0.11.0 h1:XqGyJ8ufbCE0HmTDwx2kPdsrQ36AGPZNZX6s6xfJH10= +github.com/multiformats/go-multiaddr v0.11.0/go.mod h1:gWUm0QLR4thQ6+ZF6SXUw8YjtwQSPapICM+NmCkxHSM= +github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g= +github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk= +github.com/multiformats/go-multicodec v0.9.0 h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg= +github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k= +github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U= +github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM= +github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8= +github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f h1:KUppIJq7/+SVif2QVs3tOP0zanoHgBEVAwHxUSIzRqU= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= @@ -941,8 +978,12 @@ github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLA github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= +github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a h1:dlRvE5fWabOchtH7znfiFCcOvmIYgOeAS5ifBXBlh9Q= +github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s= github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs= github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA= +github.com/oklog/run v1.1.0 h1:GEenZ1cK0+q0+wsJew9qUg/DyD8k3JzYsZAi5gYi2mA= +github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DVU= github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= @@ -960,17 +1001,15 @@ github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7J github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro= -github.com/onsi/gomega v1.20.0 h1:8W0cWlwFkflGPLltQvLRB7ZVD5HuP6ng320w2IS245Q= -github.com/onsi/gomega v1.20.0/go.mod h1:DtrZpjmvpn2mPm4YWQa0/ALMDj9v4YxLgojwPeREyVo= +github.com/onsi/gomega v1.27.8 h1:gegWiwZjBsf2DgiSbf5hpokZ98JVDMcWkUiigk6/KXc= +github.com/onsi/gomega v1.27.8/go.mod h1:2J8vzI/s+2shY9XHRApDkdgPo1TKT7P2u6fXeJKFnNQ= github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk= github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= -github.com/opencontainers/image-spec v1.1.0-rc2 h1:2zx/Stx4Wc5pIPDvIxHXvXtQFW/7XWJGmnM7r3wg034= -github.com/opencontainers/image-spec v1.1.0-rc2/go.mod h1:3OVijpioIKYWTqjiG0zfF6wvoJ4fAXGbjdZuI2NgsRQ= -github.com/opencontainers/runc v1.1.3 h1:vIXrkId+0/J2Ymu2m7VjGvbSlAId9XNRPhn2p4b+d8w= -github.com/opencontainers/runc v1.1.3/go.mod h1:1J5XiS+vdZ3wCyZybsuxXZWGrgSr8fFJHLXuG2PsnNg= -github.com/opencontainers/runtime-spec v1.0.3-0.20210326190908-1c3f411f0417/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= -github.com/opencontainers/selinux v1.10.0/go.mod h1:2i0OySw99QjzBBQByd1Gr9gSjvuho1lHsJxIJ3gGbJI= +github.com/opencontainers/image-spec v1.1.0-rc2.0.20221005185240-3a7f492d3f1b h1:YWuSjZCQAPM8UUBLkYUk1e+rZcvWHJmFb6i6rM44Xs8= +github.com/opencontainers/image-spec v1.1.0-rc2.0.20221005185240-3a7f492d3f1b/go.mod h1:3OVijpioIKYWTqjiG0zfF6wvoJ4fAXGbjdZuI2NgsRQ= +github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss= +github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8= github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis= github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74= github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= @@ -989,12 +1028,12 @@ github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtP github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= -github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ= -github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4= +github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4= +github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc= github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac= github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5/go.mod h1:jvVRKCrJTQWu0XVbaOlby/2lO20uSCHEMzzplHXte1o= -github.com/petermattis/goid v0.0.0-20230317030725-371a4b8eda08 h1:hDSdbBuw3Lefr6R18ax0tZ2BJeNB3NehB3trOwYBsdU= -github.com/petermattis/goid v0.0.0-20230317030725-371a4b8eda08/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4= +github.com/petermattis/goid v0.0.0-20230904192822-1876fd5063bc h1:8bQZVK1X6BJR/6nYUPxQEP+ReTsceJTKizeuwjWOPUA= +github.com/petermattis/goid v0.0.0-20230904192822-1876fd5063bc/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4= github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc= github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= github.com/pierrec/xxHash v0.1.5 h1:n/jBpwTHiER4xYvK3/CdPVnLDPchj8eTJFFLUb4QHBo= @@ -1007,9 +1046,9 @@ github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA= -github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs= @@ -1017,42 +1056,37 @@ github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5Fsn github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og= github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU= github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M= -github.com/prometheus/client_golang v1.15.0 h1:5fCgGYogn0hFdhyhLbw7hEsWxufKtY9klyvdNfFlFhM= -github.com/prometheus/client_golang v1.15.0/go.mod h1:e9yaBhRPU2pPNsZwE+JdQl0KEt1N9XgF6zxWmaC0xOk= +github.com/prometheus/client_golang v1.18.0 h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk= +github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4= -github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= +github.com/prometheus/client_model v0.6.0 h1:k1v3CzpSRUTrKMppY35TLwPvxHqBu0bYgxZzqGIgaos= +github.com/prometheus/client_model v0.6.0/go.mod h1:NTQHnmxFpouOD0DpvP4XujX3CdOAGQPoaGhyTchlyt8= github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA= github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4= github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s= -github.com/prometheus/common v0.42.0 h1:EKsfXEYo4JpWMHH5cg+KOUWeuJSov1Id8zGR8eeI1YM= -github.com/prometheus/common v0.42.0/go.mod h1:xBwqVerjNdUDjgODMpudtOMwlOwf2SaTr1yjz4b7Zbc= +github.com/prometheus/common v0.47.0 h1:p5Cz0FNHo7SnWOmWmoRozVcjEp0bIVU8cV7OShpjL1k= +github.com/prometheus/common v0.47.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= github.com/prometheus/procfs v0.3.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= -github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI= -github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY= -github.com/prometheus/tsdb v0.7.1 h1:YZcsG11NqnK4czYLrWd9mpEuAJIHVQLwdrleYfszMAA= -github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= -github.com/rakyll/statik v0.1.7 h1:OF3QCZUuyPxuGEP7B4ypUa7sB/iHtqOTDYZXGM8KOdQ= -github.com/rakyll/statik v0.1.7/go.mod h1:AlZONWzMtEnMs7W4e/1LURLiI49pIMmp6V9Unghqrcc= +github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= +github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/regen-network/protobuf v1.3.3-alpha.regen.1 h1:OHEc+q5iIAXpqiqFKeLpu5NwTIkVXUs48vFMwzqpqY4= github.com/regen-network/protobuf v1.3.3-alpha.regen.1/go.mod h1:2DjTFR1HhMQhiWC5sZ4OhQ3+NtdbZ6oBDKQwq5Ou+FI= -github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/rivo/uniseg v0.4.3 h1:utMvzDsuh3suAEnhH0RdHmoPbU648o6CvXxTx4SBMOw= @@ -1061,23 +1095,26 @@ github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6So github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= -github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= github.com/rs/cors v1.8.3 h1:O+qNyWn7Z+F9M0ILBHgMVPuB1xTOucVd5gtaYyXBpRo= github.com/rs/cors v1.8.3/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= -github.com/rs/zerolog v1.30.0 h1:SymVODrcRsaRaSInD9yQtKbtWqwsfoPcRff/oRXLj4c= -github.com/rs/zerolog v1.30.0/go.mod h1:/tk+P47gFdPXq4QYjvCmT5/Gsug2nagsFWBWhAiSi1w= +github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0= +github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= +github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E= github.com/sasha-s/go-deadlock v0.3.1 h1:sqv7fDNShgjcaxkO0JNcOAlr8B9+cV5Ey/OB71efZx0= github.com/sasha-s/go-deadlock v0.3.1/go.mod h1:F73l+cr82YSh10GxyRI6qZiCgK64VaZjwesgfQ1/iLM= github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= -github.com/seccomp/libseccomp-golang v0.9.2-0.20220502022130-f33da4d89646/go.mod h1:JA8cRccbGaA1s33RQf7Y1+q9gHmZX1yB/z9WDN1C6fg= github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= @@ -1085,40 +1122,39 @@ github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPx github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= -github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= -github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0= -github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM= github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= -github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 h1:RC6RW7j+1+HkWaX/Yh71Ee5ZHaHYt7ZP4sQgUrm6cDU= -github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572/go.mod h1:w0SWMsp6j9O/dk4/ZpIhL+3CkG8ofA2vuv7k+ltqUMc= +github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= +github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= -github.com/spf13/afero v1.9.5 h1:stMpOSZFs//0Lv29HduCmli3GUfpFoF3Y1Q/aXj/wVM= -github.com/spf13/afero v1.9.5/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= -github.com/spf13/cast v1.5.1 h1:R+kOtfhWQE6TVQzY+4D7wJLBgkdVasCEFxSUBYBYIlA= -github.com/spf13/cast v1.5.1/go.mod h1:b9PdjNptOpzXr7Rq1q9gJML/2cdGQAo69NKzQ10KN48= +github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0= +github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= -github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I= -github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0= +github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0= +github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho= github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= -github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= -github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= -github.com/spf13/viper v1.16.0 h1:rGGH0XDZhdUOryiDWjmIvUSWpbNqisK8Wk0Vyefw8hc= -github.com/spf13/viper v1.16.0/go.mod h1:yg78JgCJcbrQOvV9YLXgkLaZqUidkY9K+Dd1FofRzQg= -github.com/strangelove-ventures/interchaintest/v7 v7.0.0-20230608002938-79172615eed0 h1:WoRj3il7OqGknKxf3IRwGTY65AVbTnDjKAgezpEHM3E= -github.com/strangelove-ventures/interchaintest/v7 v7.0.0-20230608002938-79172615eed0/go.mod h1:RG6EsHW08mfwJQmZykqzkAQwAmVojcrqujjFBFPIHcY= +github.com/spf13/viper v1.18.2 h1:LUXCnvUvSM6FXAsj6nnfc8Q2tp1dIgUfY9Kc8GsSOiQ= +github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk= +github.com/strangelove-ventures/cometbft-client v0.1.0 h1:fcA652QaaR0LDnyJOZVjZKtuyAawnVXaq/p1MWJSYD4= +github.com/strangelove-ventures/cometbft-client v0.1.0/go.mod h1:QzThgjzvsGgUNVNpGPitmxOWMIhp6a0oqf80nCRNt/0= +github.com/strangelove-ventures/interchaintest/v8 v8.0.1-0.20231114192524-e3719592933b h1:VDe2ofJ2xiiLwkJ6qhcF2gvg75gB4WVpXO8lFzhYQOU= +github.com/strangelove-ventures/interchaintest/v8 v8.0.1-0.20231114192524-e3719592933b/go.mod h1:TbVaBTSa9Y7/Jj/JeqoH79fAcyQiHloz1zxXxKjtCFA= github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= @@ -1138,24 +1174,23 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/subosito/gotenv v1.4.2 h1:X1TuBLAMDFbaTAChgCBLu3DU3UPyELpnF2jjJ2cz/S8= -github.com/subosito/gotenv v1.4.2/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0= -github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= +github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d h1:vfofYNRScrDdvS342BElfbETmL1Aiz3i2t0zfRj16Hs= github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d/go.mod h1:RRCYJbIwD5jmqPI9XoAFR0OcDxqUctll6zUj/+B4S48= github.com/tendermint/go-amino v0.16.0 h1:GyhmgQKvqF82e2oZeuMSp9JTN0N09emoSZlb2lyGa2E= github.com/tendermint/go-amino v0.16.0/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME= -github.com/tidwall/btree v1.6.0 h1:LDZfKfQIBHGHWSwckhXI0RPSXzlo+KYdjK7FWSqOzzg= -github.com/tidwall/btree v1.6.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EUQ2cKY= -github.com/tklauser/go-sysconf v0.3.10 h1:IJ1AZGZRWbY8T5Vfk04D9WOA5WSejdflXxP03OUqALw= -github.com/tklauser/go-sysconf v0.3.10/go.mod h1:C8XykCvCb+Gn0oNCWPIlcb0RuglQTYaQ2hGm7jmxEFk= -github.com/tklauser/numcpus v0.4.0 h1:E53Dm1HjH1/R2/aoCtXtPgzmElmn51aOkhCFSuZq//o= -github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ= +github.com/tidwall/btree v1.7.0 h1:L1fkJH/AuEh5zBnnBbmTwQ5Lt+bRJ5A8EWecslvo9iI= +github.com/tidwall/btree v1.7.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EUQ2cKY= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= github.com/tyler-smith/go-bip32 v1.0.0 h1:sDR9juArbUgX+bO/iblgZnMPeWY1KZMUC2AFUJdv5KE= @@ -1166,15 +1201,13 @@ github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo= github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= -github.com/ugorji/go/codec v1.2.7 h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0= -github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY= +github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= +github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= github.com/ulikunitz/xz v0.5.11 h1:kpFauv27b6ynzBNT/Xy+1k+fK4WswhN/6PN5WhFAGw8= github.com/ulikunitz/xz v0.5.11/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= -github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE= -github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= @@ -1183,13 +1216,13 @@ github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -github.com/zondax/hid v0.9.1 h1:gQe66rtmyZ8VeGFcOpbuH3r7erYtNEAezCAYu8LdkJo= -github.com/zondax/hid v0.9.1/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= -github.com/zondax/ledger-go v0.14.1 h1:Pip65OOl4iJ84WTpA4BKChvOufMhhbxED3BaihoZN4c= -github.com/zondax/ledger-go v0.14.1/go.mod h1:fZ3Dqg6qcdXWSOJFKMG8GCTnD7slO/RL2feOQv8K320= +github.com/zondax/hid v0.9.2 h1:WCJFnEDMiqGF64nlZz28E9qLVZ0KSJ7xpc5DLEyma2U= +github.com/zondax/hid v0.9.2/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= +github.com/zondax/ledger-go v0.14.3 h1:wEpJt2CEcBJ428md/5MgSLsXLBos98sBOyxNmCjfUCw= +github.com/zondax/ledger-go v0.14.3/go.mod h1:IKKaoxupuB43g4NxeQmbLXv7T9AlQyie1UpHb342ycI= go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= -go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ= -go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw= +go.etcd.io/bbolt v1.3.8 h1:xs88BrvEv273UsB79e0hcVrlUWmS0a8upikMFhSyAtA= +go.etcd.io/bbolt v1.3.8/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw= go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= @@ -1206,19 +1239,21 @@ go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqe go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= -go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ= -go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= -go.uber.org/goleak v1.1.12 h1:gZAh5/EyT/HQwlpkCy6wTpqfH9H8Lz8zbm3dZh+OyzA= -go.uber.org/goleak v1.1.12/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk= +go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= +go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= -go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60= -go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg= +go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= +go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= +go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= golang.org/x/crypto v0.0.0-20170613210332-850760c427c5/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= @@ -1232,12 +1267,9 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA= -golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio= +golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -1249,8 +1281,8 @@ golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= -golang.org/x/exp v0.0.0-20230711153332-06a737ee72cb h1:xIApU0ow1zwMa2uL1VDNeQlNVFTWMQxZUZCMDy0Q4Us= -golang.org/x/exp v0.0.0-20230711153332-06a737ee72cb/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= +golang.org/x/exp v0.0.0-20240213143201-ec583247a57a h1:HinSgX1tJRX3KsL//Gxynpw5CTOAIPhgL4W8PNiIpVE= +golang.org/x/exp v0.0.0-20240213143201-ec583247a57a/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= @@ -1277,8 +1309,8 @@ golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU= -golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.15.0 h1:SernR4v+D55NyBH2QiEQrlBAnj1ECL6AGrA5+dPaMY8= +golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -1321,7 +1353,6 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= @@ -1329,7 +1360,6 @@ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96b golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= @@ -1342,8 +1372,8 @@ golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= -golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50= -golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA= +golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= +golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -1369,8 +1399,8 @@ golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= golang.org/x/oauth2 v0.1.0/go.mod h1:G9FE4dLTsbXUu90h/Pf85g4w1D+SSAgR+q46nJZ8M4A= -golang.org/x/oauth2 v0.8.0 h1:6dkIjl3j3LtZ/O3sTgZTMsLKSftL/B8Zgq4huOIIUu8= -golang.org/x/oauth2 v0.8.0/go.mod h1:yr7u4HXZRm1R1kBWqr/xKNqewf0plRYoB7sla+BCIXE= +golang.org/x/oauth2 v0.16.0 h1:aDkGMBSYxElaoP81NpoUoz2oo2R2wHdZpGToUxfyQrQ= +golang.org/x/oauth2 v0.16.0/go.mod h1:hqZ+0LWXsiVoZpeld6jVt06P3adbS2Uu911W1SsJv2o= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -1385,8 +1415,8 @@ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI= -golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= +golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1404,7 +1434,6 @@ golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1413,7 +1442,6 @@ golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191115151921-52ab43148777/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1445,15 +1473,12 @@ golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -1464,11 +1489,9 @@ golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210819135213-f52c844e1c1c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210906170528-6f6e22806c34/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211116061358-0a5406a5449c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -1485,22 +1508,22 @@ golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM= -golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.10.0 h1:3R7pNqamzBraeqj/Tj8qt1aQ2HpmlC+Cx/qL/7hn4/c= -golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o= +golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U= +golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1512,14 +1535,14 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc= -golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= -golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -1539,6 +1562,7 @@ golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -1573,7 +1597,6 @@ golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= @@ -1581,8 +1604,8 @@ golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.9.3 h1:Gn1I8+64MsuTb/HpH+LmQtNas23LhUVr3rYZ0eKuaMM= -golang.org/x/tools v0.9.3/go.mod h1:owI94Op576fPu3cIGQeHs3joujW/2Oc6MtlxbF5dfNc= +golang.org/x/tools v0.18.0 h1:k8NLag8AGHnn+PHbl7g43CtqZAwG60vZkLqgyZgIHgQ= +golang.org/x/tools v0.18.0/go.mod h1:GL7B4CwcLLeo59yx/9UWWuNOW1n3VZ4f5axWfML7Lcg= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -1641,8 +1664,8 @@ google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= -google.golang.org/api v0.126.0 h1:q4GJq+cAdMAC7XP7njvQ4tvohGLiSlytuL4BQxbIZ+o= -google.golang.org/api v0.126.0/go.mod h1:mBwVAtz+87bEN6CbA1GtZPDOqY2R5ONPqJeIlvyo4Aw= +google.golang.org/api v0.153.0 h1:N1AwGhielyKFaUqH07/ZSIQR3uNPcV7NVw0vj+j4iR4= +google.golang.org/api v0.153.0/go.mod h1:3qNJX5eOmhiWYc67jRA/3GsDw97UFb5ivv7Y2PrriAY= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -1650,8 +1673,9 @@ google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7 google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c= google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= +google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= @@ -1691,10 +1715,8 @@ google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210126160654-44e461bb6506/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= @@ -1761,12 +1783,12 @@ google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqw google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= google.golang.org/genproto v0.0.0-20221025140454-527a21cfbd71/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= -google.golang.org/genproto v0.0.0-20230706204954-ccb25ca9f130 h1:Au6te5hbKUV8pIYWHqOUZ1pva5qK/rwbIhoXEUB9Lu8= -google.golang.org/genproto v0.0.0-20230706204954-ccb25ca9f130/go.mod h1:O9kGHb51iE/nOGvQaDUuadVYqovW56s5emA88lQnj6Y= -google.golang.org/genproto/googleapis/api v0.0.0-20230629202037-9506855d4529 h1:s5YSX+ZH5b5vS9rnpGymvIyMpLRJizowqDlOuyjXnTk= -google.golang.org/genproto/googleapis/api v0.0.0-20230629202037-9506855d4529/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= -google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98 h1:bVf09lpb+OJbByTj913DRJioFFAjf/ZGxEz7MajTp2U= -google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98/go.mod h1:TUfxEVdsvPg18p6AslUXFoLdpED4oBnGwyqk3dV1XzM= +google.golang.org/genproto v0.0.0-20231211222908-989df2bf70f3 h1:1hfbdAfFbkmpg41000wDVqr7jUpK/Yo+LPnIxxGzmkg= +google.golang.org/genproto v0.0.0-20231211222908-989df2bf70f3/go.mod h1:5RBcpGRxr25RbDzY5w+dmaqpSEvl8Gwl1x2CICf60ic= +google.golang.org/genproto/googleapis/api v0.0.0-20231120223509-83a465c0220f h1:2yNACc1O40tTnrsbk9Cv6oxiW8pxI/pXj0wRtdlYmgY= +google.golang.org/genproto/googleapis/api v0.0.0-20231120223509-83a465c0220f/go.mod h1:Uy9bTZJqmfrw2rIBxgGLnamc78euZULUBrLZ9XTITKI= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231212172506-995d672761c0 h1:/jFB8jK5R3Sq3i/lmeZO0cATSzFfZaJq1J2Euan3XKU= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231212172506-995d672761c0/go.mod h1:FUoWkonphQm3RhTS+kOEhF8h0iDpm4tdXolVCeZ9KKA= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM= @@ -1808,8 +1830,8 @@ google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACu google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= -google.golang.org/grpc v1.56.2 h1:fVRFRnXvU+x6C4IlHZewvJOVHoOv1TUuQyoRsYnB4bI= -google.golang.org/grpc v1.56.2/go.mod h1:I9bI3vqKfayGqPUAwGdOSu7kt6oIJLixfffKrpXqQ9s= +google.golang.org/grpc v1.60.1 h1:26+wFr+cNqSGFcOXcabYC0lUVJVRa2Sb2ortSK7VrEU= +google.golang.org/grpc v1.60.1/go.mod h1:OlCHIeLYqSSsLi6i49B5QGdzaMZK9+M7LXN2FKz4eGM= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= @@ -1826,8 +1848,8 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= -google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= -google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I= +google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= @@ -1862,9 +1884,8 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo= -gotest.tools/v3 v3.5.0 h1:Ljk6PdHdOhAb5aDMWXjDLMMhph+BpztA4v1QdqEW2eY= -gotest.tools/v3 v3.5.0/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU= +gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU= +gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU= honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= @@ -1875,8 +1896,8 @@ honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9 honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= launchpad.net/gocheck v0.0.0-20140225173054-000000000087 h1:Izowp2XBH6Ya6rv+hqbceQyw/gSGoXfH/UPoTGduL54= launchpad.net/gocheck v0.0.0-20140225173054-000000000087/go.mod h1:hj7XX3B/0A+80Vse0e+BUHsHMTEhd0O4cpUHr/e/BUM= -lukechampine.com/blake3 v1.1.7 h1:GgRMhmdsuK8+ii6UZFDL8Nb+VyMwadAgcJyfYHxG6n0= -lukechampine.com/blake3 v1.1.7/go.mod h1:tkKEOtDkNtklkXtLNEOGNq5tcV90tJiA1vAA12R78LA= +lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI= +lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k= lukechampine.com/uint128 v1.2.0 h1:mBi/5l91vocEN8otkC5bDLhi2KdCticRiwbdB0O+rjI= lukechampine.com/uint128 v1.2.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= modernc.org/cc/v3 v3.40.0 h1:P3g79IUS/93SYhtoeaHW+kRCIrYaxJ27MFPv+7kaTOw= @@ -1887,16 +1908,16 @@ modernc.org/ccorpus v1.11.6 h1:J16RXiiqiCgua6+ZvQot4yUuUy8zxgqbqEEUuGPlISk= modernc.org/ccorpus v1.11.6/go.mod h1:2gEUTrWqdpH2pXsmTM1ZkjeSrUWDpjMu2T6m29L/ErQ= modernc.org/httpfs v1.0.6 h1:AAgIpFZRXuYnkjftxTAZwMIiwEqAfk8aVB2/oA6nAeM= modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM= -modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE= -modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY= -modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ= -modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= -modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds= -modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= +modernc.org/libc v1.29.0 h1:tTFRFq69YKCF2QyGNuRUQxKBm1uZZLubf6Cjh/pVHXs= +modernc.org/libc v1.29.0/go.mod h1:DaG/4Q3LRRdqpiLyP0C2m1B8ZMGkQ+cCgOIjEtQlYhQ= +modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= +modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= +modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E= +modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E= modernc.org/opt v0.1.3 h1:3XOZf2yznlhC+ibLltsDGzABUGVx8J6pnFMS3E4dcq4= modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= -modernc.org/sqlite v1.23.0 h1:MWTFBI5H1WLnXpNBh/BTruBVqzzoh28DA0iOnlkkRaM= -modernc.org/sqlite v1.23.0/go.mod h1:OrDj17Mggn6MhE+iPbBNf7RGKODDE9NFT0f3EwDzJqk= +modernc.org/sqlite v1.27.0 h1:MpKAHoyYB7xqcwnUwkuD+npwEa0fojF0B5QRbN+auJ8= +modernc.org/sqlite v1.27.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0= modernc.org/strutil v1.1.3 h1:fNMm+oJklMGYfU9Ylcywl0CO5O6nTfaowNsh2wpPjzY= modernc.org/strutil v1.1.3/go.mod h1:MEHNA7PdEnEwLvspRMtWTNnp2nnyvMfkimT1NKNAGbw= modernc.org/tcl v1.15.2 h1:C4ybAYCGJw968e+Me18oW55kD/FexcHbqH2xak1ROSY= @@ -1905,14 +1926,17 @@ modernc.org/token v1.0.1 h1:A3qvTqOwexpfZZeyI0FeGPDlSWX5pjZu9hF4lU+EKWg= modernc.org/token v1.0.1/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= modernc.org/z v1.7.3 h1:zDJf6iHjrnB+WRD88stbXokugjyc0/pB91ri1gO6LZY= modernc.org/z v1.7.3/go.mod h1:Ipv4tsdxZRbQyLq9Q1M6gdbkxYzdlrciF2Hi/lS7nWE= -nhooyr.io/websocket v1.8.6 h1:s+C3xAMLwGmlI31Nyn/eAehUlZPwfYZu2JXM621Q5/k= nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0= -pgregory.net/rapid v0.5.5 h1:jkgx1TjbQPD/feRoK+S/mXw9e1uj6WilpHrXJowi6oA= -pgregory.net/rapid v0.5.5/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= +nhooyr.io/websocket v1.8.7 h1:usjR2uOr/zjjkVMy0lW+PPohFok7PCow5sDjLgX4P4g= +nhooyr.io/websocket v1.8.7/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0= +pgregory.net/rapid v1.1.0 h1:CMa0sjHSru3puNx+J0MIAuiiEV4N0qj8/cMWGBBCsjw= +pgregory.net/rapid v1.1.0/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= -sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= -sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= +sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E= +sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU= diff --git a/interchaintest/ibc_test.go b/interchaintest/ibc_test.go index 81140ba74..3d5a45cdf 100644 --- a/interchaintest/ibc_test.go +++ b/interchaintest/ibc_test.go @@ -6,11 +6,11 @@ import ( relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" "github.com/cosmos/relayer/v2/relayer" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/conformance" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v7/relayer" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/conformance" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v8/relayer" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" "go.uber.org/zap/zaptest" ) @@ -22,10 +22,26 @@ import ( // // The canonical set of test chains are defined in the interchaintest repository. func interchaintestConformance(t *testing.T, rf interchaintest.RelayerFactory) { + nf := 1 + nv := 1 + cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ - {Name: "gaia", Version: "v7.0.1", ChainConfig: ibc.ChainConfig{ChainID: "cosmoshub-1004"}}, - {Name: "osmosis", Version: "v7.2.0", ChainConfig: ibc.ChainConfig{ChainID: "osmosis-1001"}}, + { + Name: "gaia", + Version: "v14.1.0", + NumValidators: &nv, + NumFullNodes: &nf, + ChainConfig: ibc.ChainConfig{ChainID: "cosmoshub-1004"}, + }, + { + Name: "osmosis", + Version: "v22.0.0", + NumValidators: &nv, + NumFullNodes: &nf, + ChainConfig: ibc.ChainConfig{ChainID: "osmosis-1001"}, + }, }) + conformance.Test( t, context.Background(), diff --git a/interchaintest/ica_channel_close_test.go b/interchaintest/ica_channel_close_test.go index 6eac44b64..b1682593e 100644 --- a/interchaintest/ica_channel_close_test.go +++ b/interchaintest/ica_channel_close_test.go @@ -3,18 +3,18 @@ package interchaintest_test import ( "context" "encoding/json" - "strconv" "testing" "time" + sdkmath "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/crypto/keyring" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) @@ -42,8 +42,9 @@ func TestScenarioICAChannelClose(t *testing.T) { NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ - Images: []ibc.DockerImage{{Repository: "ghcr.io/cosmos/ibc-go-icad", Version: "v0.5.0"}}, - UsingNewGenesisCommand: true, + Images: []ibc.DockerImage{ + {Repository: "ghcr.io/cosmos/ibc-go-icad", Version: "v0.5.0", UidGid: "1025:1025"}, + }, }, }, { @@ -51,8 +52,9 @@ func TestScenarioICAChannelClose(t *testing.T) { NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ - Images: []ibc.DockerImage{{Repository: "ghcr.io/cosmos/ibc-go-icad", Version: "v0.5.0"}}, - UsingNewGenesisCommand: true, + Images: []ibc.DockerImage{ + {Repository: "ghcr.io/cosmos/ibc-go-icad", Version: "v0.5.0", UidGid: "1025:1025"}, + }, }, }, }) @@ -94,8 +96,8 @@ func TestScenarioICAChannelClose(t *testing.T) { t.Parallel() // Fund a user account on chain1 and chain2 - const userFunds = int64(10_000_000_000) - users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), userFunds, chain1, chain2) + initBal := sdkmath.NewInt(10_000_000_000) + users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), initBal, chain1, chain2) chain1User := users[0] chain2User := users[1] @@ -188,7 +190,7 @@ func TestScenarioICAChannelClose(t *testing.T) { require.NoError(t, err) // Send funds to ICA from user account on chain2 - const transferAmount = 10000 + transferAmount := sdkmath.NewInt(10000) transfer := ibc.WalletAmount{ Address: icaAddr, Denom: chain2.Config().Denom, @@ -199,11 +201,11 @@ func TestScenarioICAChannelClose(t *testing.T) { chain2Bal, err := chain2.GetBalance(ctx, chain2Addr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, chain2OrigBal-transferAmount, chain2Bal) + require.True(t, chain2OrigBal.Sub(transferAmount).Equal(chain2Bal)) icaBal, err := chain2.GetBalance(ctx, icaAddr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, icaOrigBal+transferAmount, icaBal) + require.True(t, icaOrigBal.Add(transferAmount).Equal(icaBal)) // Build bank transfer msg rawMsg, err := json.Marshal(map[string]any{ @@ -213,7 +215,7 @@ func TestScenarioICAChannelClose(t *testing.T) { "amount": []map[string]any{ { "denom": chain2.Config().Denom, - "amount": strconv.Itoa(transferAmount), + "amount": transferAmount.String(), }, }, }) @@ -250,12 +252,12 @@ func TestScenarioICAChannelClose(t *testing.T) { // Assert that the funds have been received by the user account on chain2 chain2Bal, err = chain2.GetBalance(ctx, chain2Addr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, chain2OrigBal, chain2Bal) + require.True(t, chain2OrigBal.Equal(chain2Bal)) // Assert that the funds have been removed from the ICA on chain2 icaBal, err = chain2.GetBalance(ctx, icaAddr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, icaOrigBal, icaBal) + require.True(t, icaOrigBal.Equal(icaBal)) // Stop the relayer and wait for the process to terminate err = r.StopRelayer(ctx, eRep) @@ -281,11 +283,11 @@ func TestScenarioICAChannelClose(t *testing.T) { // Assert that the packet timed out and that the acc balances are correct chain2Bal, err = chain2.GetBalance(ctx, chain2Addr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, chain2OrigBal, chain2Bal) + require.True(t, chain2OrigBal.Equal(chain2Bal)) icaBal, err = chain2.GetBalance(ctx, icaAddr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, icaOrigBal, icaBal) + require.True(t, icaOrigBal.Equal(icaBal)) // Assert that the channel ends are both closed chain1Chans, err = r.GetChannels(ctx, eRep, chain1.Config().ChainID) diff --git a/interchaintest/interchain_accounts_test.go b/interchaintest/interchain_accounts_test.go index 0ec0a1df5..dbdb71bdf 100644 --- a/interchaintest/interchain_accounts_test.go +++ b/interchaintest/interchain_accounts_test.go @@ -3,19 +3,19 @@ package interchaintest_test import ( "context" "encoding/json" - "strconv" "strings" "testing" "time" + sdkmath "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/crypto/keyring" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) @@ -43,8 +43,7 @@ func TestScenarioInterchainAccounts(t *testing.T) { NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ - Images: []ibc.DockerImage{{Repository: "ghcr.io/cosmos/ibc-go-icad", Version: "v0.5.0"}}, - UsingNewGenesisCommand: true, + Images: []ibc.DockerImage{{Repository: "ghcr.io/cosmos/ibc-go-icad", Version: "v0.5.0", UidGid: "1025:1025"}}, }, }, { @@ -52,8 +51,7 @@ func TestScenarioInterchainAccounts(t *testing.T) { NumValidators: &nv, NumFullNodes: &nf, ChainConfig: ibc.ChainConfig{ - Images: []ibc.DockerImage{{Repository: "ghcr.io/cosmos/ibc-go-icad", Version: "v0.5.0"}}, - UsingNewGenesisCommand: true, + Images: []ibc.DockerImage{{Repository: "ghcr.io/cosmos/ibc-go-icad", Version: "v0.5.0", UidGid: "1025:1025"}}, }, }, }) @@ -95,8 +93,8 @@ func TestScenarioInterchainAccounts(t *testing.T) { t.Parallel() // Fund a user account on chain1 and chain2 - const userFunds = int64(10_000_000_000) - users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), userFunds, chain1, chain2) + initBal := sdkmath.NewInt(10_000_000_000) + users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), initBal, chain1, chain2) chain1User := users[0] chain2User := users[1] @@ -189,7 +187,7 @@ func TestScenarioInterchainAccounts(t *testing.T) { require.NoError(t, err) // Send funds to ICA from user account on chain2 - const transferAmount = 10000 + transferAmount := sdkmath.NewInt(10000) transfer := ibc.WalletAmount{ Address: icaAddr, Denom: chain2.Config().Denom, @@ -200,11 +198,11 @@ func TestScenarioInterchainAccounts(t *testing.T) { chain2Bal, err := chain2.GetBalance(ctx, chain2Addr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, chain2OrigBal-transferAmount, chain2Bal) + require.True(t, chain2OrigBal.Sub(transferAmount).Equal(chain2Bal)) icaBal, err := chain2.GetBalance(ctx, icaAddr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, icaOrigBal+transferAmount, icaBal) + require.True(t, icaOrigBal.Add(transferAmount).Equal(icaBal)) // Build bank transfer msg rawMsg, err := json.Marshal(map[string]any{ @@ -214,7 +212,7 @@ func TestScenarioInterchainAccounts(t *testing.T) { "amount": []map[string]any{ { "denom": chain2.Config().Denom, - "amount": strconv.Itoa(transferAmount), + "amount": transferAmount.String(), }, }, }) @@ -251,12 +249,12 @@ func TestScenarioInterchainAccounts(t *testing.T) { // Assert that the funds have been received by the user account on chain2 chain2Bal, err = chain2.GetBalance(ctx, chain2Addr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, chain2OrigBal, chain2Bal) + require.True(t, chain2OrigBal.Equal(chain2Bal)) // Assert that the funds have been removed from the ICA on chain2 icaBal, err = chain2.GetBalance(ctx, icaAddr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, icaOrigBal, icaBal) + require.True(t, icaOrigBal.Equal(icaBal)) // Stop the relayer and wait for the process to terminate err = r.StopRelayer(ctx, eRep) @@ -288,11 +286,11 @@ func TestScenarioInterchainAccounts(t *testing.T) { // Assert that the packet timed out and that the acc balances are correct chain2Bal, err = chain2.GetBalance(ctx, chain2Addr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, chain2OrigBal, chain2Bal) + require.True(t, chain2OrigBal.Equal(chain2Bal)) icaBal, err = chain2.GetBalance(ctx, icaAddr, chain2.Config().Denom) require.NoError(t, err) - require.Equal(t, icaOrigBal, icaBal) + require.True(t, icaOrigBal.Equal(icaBal)) // Assert that the channel ends are both closed chain1Chans, err := r.GetChannels(ctx, eRep, chain1.Config().ChainID) diff --git a/interchaintest/localhost_client_test.go b/interchaintest/localhost_client_test.go index 24a9ec11d..845a46763 100644 --- a/interchaintest/localhost_client_test.go +++ b/interchaintest/localhost_client_test.go @@ -4,21 +4,69 @@ import ( "context" "encoding/json" "fmt" - "strconv" "testing" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + sdkmath "cosmossdk.io/math" + "cosmossdk.io/x/upgrade" + sdktest "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/bank" + "github.com/cosmos/cosmos-sdk/x/consensus" + distr "github.com/cosmos/cosmos-sdk/x/distribution" + "github.com/cosmos/cosmos-sdk/x/genutil" + genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types" + "github.com/cosmos/cosmos-sdk/x/gov" + govclient "github.com/cosmos/cosmos-sdk/x/gov/client" + "github.com/cosmos/cosmos-sdk/x/mint" + "github.com/cosmos/cosmos-sdk/x/params" + paramsclient "github.com/cosmos/cosmos-sdk/x/params/client" + "github.com/cosmos/cosmos-sdk/x/slashing" + "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/ibc-go/modules/capability" + ica "github.com/cosmos/ibc-go/v8/modules/apps/27-interchain-accounts" + icatypes "github.com/cosmos/ibc-go/v8/modules/apps/27-interchain-accounts/types" + "github.com/cosmos/ibc-go/v8/modules/apps/transfer" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + ibccore "github.com/cosmos/ibc-go/v8/modules/core" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + ibctm "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" relayertest "github.com/cosmos/relayer/v2/interchaintest" - "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + ibcwasm "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos/08-wasm-types" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) +func DefaultEncoding() sdktest.TestEncodingConfig { + return sdktest.MakeTestEncodingConfig( + auth.AppModuleBasic{}, + genutil.NewAppModuleBasic(genutiltypes.DefaultMessageValidator), + bank.AppModuleBasic{}, + capability.AppModuleBasic{}, + staking.AppModuleBasic{}, + mint.AppModuleBasic{}, + distr.AppModuleBasic{}, + gov.NewAppModuleBasic( + []govclient.ProposalHandler{ + paramsclient.ProposalHandler, + }, + ), + params.AppModuleBasic{}, + slashing.AppModuleBasic{}, + upgrade.AppModuleBasic{}, + consensus.AppModuleBasic{}, + ica.AppModuleBasic{}, + transfer.AppModuleBasic{}, + ibccore.AppModuleBasic{}, + ibctm.AppModuleBasic{}, + ibcwasm.AppModuleBasic{}, + ) +} + func TestLocalhost_TokenTransfers(t *testing.T) { if testing.Short() { t.Skip() @@ -30,10 +78,10 @@ func TestLocalhost_TokenTransfers(t *testing.T) { numFullNodes := 0 image := ibc.DockerImage{ Repository: "ghcr.io/cosmos/ibc-go-simd", - Version: "v7.1.0-rc0", - UidGid: "", + Version: "v8.0.0", + UidGid: "100:1000", } - cdc := cosmos.DefaultEncoding() + cdc := DefaultEncoding() cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ { Name: "ibc-go-simd", @@ -42,18 +90,17 @@ func TestLocalhost_TokenTransfers(t *testing.T) { NumValidators: &numVals, NumFullNodes: &numFullNodes, ChainConfig: ibc.ChainConfig{ - Type: "cosmos", - Name: "simd", - ChainID: "chain-a", - Images: []ibc.DockerImage{image}, - Bin: "simd", - Bech32Prefix: "cosmos", - Denom: "stake", - CoinType: "118", - GasPrices: "0.0stake", - GasAdjustment: 1.1, - EncodingConfig: &cdc, - UsingNewGenesisCommand: true, + Type: "cosmos", + Name: "simd", + ChainID: "chain-a", + Images: []ibc.DockerImage{image}, + Bin: "simd", + Bech32Prefix: "cosmos", + Denom: "stake", + CoinType: "118", + GasPrices: "0.0stake", + GasAdjustment: 1.1, + EncodingConfig: &cdc, }}}, ) @@ -92,7 +139,7 @@ func TestLocalhost_TokenTransfers(t *testing.T) { const mnemonic = "all unit ordinary card sword document left illegal frog chuckle assume gift south settle can explain wagon beef story praise gorilla arch close good" // initialize a new acc for the relayer along with a couple user accs - initBal := int64(10_000_000) + initBal := sdkmath.NewInt(10_000_000) _, err = interchaintest.GetAndFundTestUserWithMnemonic(ctx, relayerKey, mnemonic, initBal, chainA) require.NoError(t, err) @@ -105,11 +152,11 @@ func TestLocalhost_TokenTransfers(t *testing.T) { // assert initial balances are correct userABal, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, initBal, userABal) + require.True(t, initBal.Equal(userABal)) userBBal, err := chainA.GetBalance(ctx, userB.FormattedAddress(), chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, initBal, userBBal) + require.True(t, initBal.Equal(userBBal)) // configure the relayer for a localhost connection err = r.AddChainConfiguration(ctx, eRep, chainA.Config(), relayerKey, chainA.GetHostRPCAddress(), chainA.GetHostGRPCAddress()) @@ -161,7 +208,7 @@ func TestLocalhost_TokenTransfers(t *testing.T) { ) // compose and send a localhost IBC transfer which should be successful - const transferAmount = int64(1_000) + transferAmount := sdkmath.NewInt(1_000) transfer := ibc.WalletAmount{ Address: userB.FormattedAddress(), Denom: chainA.Config().Denom, @@ -172,7 +219,7 @@ func TestLocalhost_TokenTransfers(t *testing.T) { chainA.Config().Bin, "tx", "ibc-transfer", "transfer", "transfer", channel.ChannelID, transfer.Address, - fmt.Sprintf("%d%s", transfer.Amount, transfer.Denom), + fmt.Sprintf("%s%s", transfer.Amount.String(), transfer.Denom), "--from", userA.FormattedAddress(), "--gas-prices", "0.0stake", "--gas-adjustment", "1.2", @@ -194,18 +241,18 @@ func TestLocalhost_TokenTransfers(t *testing.T) { // assert that the updated balances are correct newBalA, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, userABal-transferAmount, newBalA) + require.True(t, userABal.Sub(transferAmount).Equal(newBalA)) newBalB, err := chainA.GetBalance(ctx, userB.FormattedAddress(), trace.IBCDenom()) require.NoError(t, err) - require.Equal(t, transferAmount, newBalB) + require.True(t, transferAmount.Equal(newBalB)) // compose and send another localhost IBC transfer which should succeed cmd = []string{ chainA.Config().Bin, "tx", "ibc-transfer", "transfer", "transfer", channel.ChannelID, transfer.Address, - fmt.Sprintf("%d%s", transfer.Amount, transfer.Denom), + fmt.Sprintf("%s%s", transfer.Amount.String(), transfer.Denom), "--from", userA.FormattedAddress(), "--gas-prices", "0.0stake", "--gas-adjustment", "1.2", @@ -228,12 +275,12 @@ func TestLocalhost_TokenTransfers(t *testing.T) { tmpBalA := newBalA newBalA, err = chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, tmpBalA-transferAmount, newBalA) + require.True(t, tmpBalA.Sub(transferAmount).Equal(newBalA)) tmpBalB := newBalB newBalB, err = chainA.GetBalance(ctx, userB.FormattedAddress(), trace.IBCDenom()) require.NoError(t, err) - require.Equal(t, tmpBalB+transferAmount, newBalB) + require.True(t, tmpBalB.Add(transferAmount).Equal(newBalB)) } func TestLocalhost_InterchainAccounts(t *testing.T) { @@ -247,8 +294,8 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { numFullNodes := 0 image := ibc.DockerImage{ Repository: "ghcr.io/cosmos/ibc-go-simd", - Version: "v7.1.0-rc0", - UidGid: "", + Version: "v8.0.0-beta.1", + UidGid: "100:1000", } cdc := cosmos.DefaultEncoding() cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ @@ -259,18 +306,17 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { NumValidators: &numVals, NumFullNodes: &numFullNodes, ChainConfig: ibc.ChainConfig{ - Type: "cosmos", - Name: "simd", - ChainID: "chain-a", - Images: []ibc.DockerImage{image}, - Bin: "simd", - Bech32Prefix: "cosmos", - Denom: "stake", - CoinType: "118", - GasPrices: "0.0stake", - GasAdjustment: 1.1, - EncodingConfig: &cdc, - UsingNewGenesisCommand: true, + Type: "cosmos", + Name: "simd", + ChainID: "chain-a", + Images: []ibc.DockerImage{image}, + Bin: "simd", + Bech32Prefix: "cosmos", + Denom: "stake", + CoinType: "118", + GasPrices: "0.0stake", + GasAdjustment: 1.1, + EncodingConfig: &cdc, }}}, ) @@ -311,7 +357,7 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { ) // initialize a new acc for the relayer along with a new user acc - const initBal = int64(10_000_000) + initBal := sdkmath.NewInt(10_000_000) _, err = interchaintest.GetAndFundTestUserWithMnemonic(ctx, relayerKey, mnemonic, initBal, chainA) require.NoError(t, err) @@ -324,7 +370,7 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { // assert initial balance is correct userABal, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, initBal, userABal) + require.True(t, initBal.Equal(userABal)) // configure the relayer for a localhost connection err = r.AddChainConfiguration(ctx, eRep, chainA.Config(), relayerKey, chainA.GetHostRPCAddress(), chainA.GetHostGRPCAddress()) @@ -358,7 +404,14 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { }, ) + // wait for the relayer to start up + err = testutil.WaitForBlocks(ctx, 10, chainA) + require.NoError(t, err) + // register a new interchain account + metadata := icatypes.NewDefaultMetadata(ibcexported.LocalhostConnectionID, ibcexported.LocalhostConnectionID) + bz, err := json.Marshal(metadata) + require.NoError(t, err) registerCmd := []string{ chainA.Config().Bin, "tx", "interchain-accounts", "controller", "register", ibcexported.LocalhostConnectionID, "--from", userA.FormattedAddress(), @@ -370,12 +423,13 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { "--home", chainA.HomeDir(), "--node", chainA.GetRPCAddress(), "--chain-id", chainA.Config().ChainID, + "--version", string(bz), } _, _, err = chainA.Exec(ctx, registerCmd, nil) require.NoError(t, err) - err = testutil.WaitForBlocks(ctx, 10, chainA) + err = testutil.WaitForBlocks(ctx, 20, chainA) require.NoError(t, err) channels, err := r.GetChannels(ctx, eRep, chainA.Config().ChainID) @@ -388,7 +442,6 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { userA.FormattedAddress(), ibcexported.LocalhostConnectionID, "--home", chainA.HomeDir(), "--node", chainA.GetRPCAddress(), - "--chain-id", chainA.Config().ChainID, } stdout, _, err := chainA.Exec(ctx, queryCmd, nil) require.NoError(t, err) @@ -399,9 +452,9 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { // asser the ICA balance, send some funds to the ICA, then re-assert balances icaBal, err := chainA.GetBalance(ctx, icaAddr, chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, int64(0), icaBal) + require.True(t, sdkmath.ZeroInt().Equal(icaBal)) - const transferAmount = 1000 + transferAmount := sdkmath.NewInt(1000) transfer := ibc.WalletAmount{ Address: icaAddr, Denom: chainA.Config().Denom, @@ -415,11 +468,11 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { newBalICA, err := chainA.GetBalance(ctx, icaAddr, chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, int64(transferAmount), newBalICA) + require.True(t, transferAmount.Equal(newBalICA)) newBalA, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, userABal-transferAmount, newBalA) + require.True(t, userABal.Sub(transferAmount).Equal(newBalA)) // compose msg to send to ICA rawMsg, err := json.Marshal(map[string]any{ @@ -429,7 +482,7 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { "amount": []map[string]any{ { "denom": chainA.Config().Denom, - "amount": strconv.Itoa(transferAmount), + "amount": transferAmount.String(), }, }, }) @@ -437,6 +490,7 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { generateCmd := []string{ chainA.Config().Bin, "tx", "interchain-accounts", "host", "generate-packet-data", string(rawMsg), + "--encoding", "proto3", } msgBz, _, err := chainA.Exec(ctx, generateCmd, nil) require.NoError(t, err) @@ -464,9 +518,9 @@ func TestLocalhost_InterchainAccounts(t *testing.T) { // assert updated balances are correct finalBalICA, err := chainA.GetBalance(ctx, icaAddr, chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, newBalICA-transferAmount, finalBalICA) + require.True(t, newBalICA.Sub(transferAmount).Equal(finalBalICA)) finalBalA, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom) require.NoError(t, err) - require.Equal(t, newBalA+int64(transferAmount), finalBalA) + require.True(t, newBalA.Add(transferAmount).Equal(finalBalA)) } diff --git a/interchaintest/memo_receiver_limit_test.go b/interchaintest/memo_receiver_limit_test.go new file mode 100644 index 000000000..ce9dd45bb --- /dev/null +++ b/interchaintest/memo_receiver_limit_test.go @@ -0,0 +1,278 @@ +package interchaintest_test + +import ( + "context" + "testing" + + sdkmath "cosmossdk.io/math" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + "github.com/cosmos/relayer/v2/cmd" + relayertest "github.com/cosmos/relayer/v2/interchaintest" + "github.com/cosmos/relayer/v2/relayer/chains/cosmos" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" + "github.com/stretchr/testify/require" + "go.uber.org/zap/zaptest" + "gopkg.in/yaml.v3" +) + +// TestMemoAndReceiverLimit tests the functionality of sending transfers with a memo and receiver limit configured. +func TestMemoAndReceiverLimit(t *testing.T) { + if testing.Short() { + t.Skip("skipping in short mode") + } + + t.Parallel() + + numVals := 1 + numFullNodes := 0 + + image := ibc.DockerImage{ + Repository: "ghcr.io/cosmos/ibc-go-simd", + Version: "v8.0.0", + UidGid: "100:1000", + } + + cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ + { + Name: "ibc-go-simd", + Version: "main", + NumValidators: &numVals, + NumFullNodes: &numFullNodes, + ChainConfig: ibc.ChainConfig{ + Type: "cosmos", + Name: "simd", + ChainID: "chain-a", + Images: []ibc.DockerImage{image}, + Bin: "simd", + Bech32Prefix: "cosmos", + Denom: "stake", + CoinType: "118", + GasPrices: "0.0stake", + GasAdjustment: 1.1, + }, + }, + { + Name: "ibc-go-simd", + Version: "main", + NumValidators: &numVals, + NumFullNodes: &numFullNodes, + ChainConfig: ibc.ChainConfig{ + Type: "cosmos", + Name: "simd", + ChainID: "chain-b", + Images: []ibc.DockerImage{image}, + Bin: "simd", + Bech32Prefix: "cosmos", + Denom: "stake", + CoinType: "118", + GasPrices: "0.0stake", + GasAdjustment: 1.1, + }, + }, + }) + + chains, err := cf.Chains(t.Name()) + require.NoError(t, err) + chainA, chainB := chains[0], chains[1] + + ctx := context.Background() + client, network := interchaintest.DockerSetup(t) + + rf := relayertest.NewRelayerFactory(relayertest.RelayerConfig{InitialBlockHistory: 50}) + r := rf.Build(t, client, network) + + const pathName = "chainA-chainB" + + ic := interchaintest.NewInterchain(). + AddChain(chainA). + AddChain(chainB). + AddRelayer(r, "relayer"). + AddLink(interchaintest.InterchainLink{ + Chain1: chainA, + Chain2: chainB, + Relayer: r, + Path: pathName, + }) + + rep := testreporter.NewNopReporter() + eRep := rep.RelayerExecReporter(t) + + require.NoError(t, ic.Build(ctx, eRep, interchaintest.InterchainBuildOptions{ + TestName: t.Name(), + Client: client, + NetworkID: network, + })) + + t.Cleanup(func() { + _ = ic.Close() + }) + + // Create and fund user accs & assert initial balances. + initBal := sdkmath.NewInt(1_000_000_000_000) + users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), initBal, chainA, chainB, chainA, chainB) + + require.NoError(t, testutil.WaitForBlocks(ctx, 2, chainA, chainB)) + + userA := users[0] + userB := users[1] + userC := users[2] + userD := users[3] + + userABal, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom) + require.NoError(t, err) + require.True(t, initBal.Equal(userABal)) + + userCBal, err := chainA.GetBalance(ctx, userC.FormattedAddress(), chainA.Config().Denom) + require.NoError(t, err) + require.True(t, initBal.Equal(userCBal)) + + userBBal, err := chainB.GetBalance(ctx, userB.FormattedAddress(), chainB.Config().Denom) + require.NoError(t, err) + require.True(t, initBal.Equal(userBBal)) + + userDBal, err := chainB.GetBalance(ctx, userD.FormattedAddress(), chainB.Config().Denom) + require.NoError(t, err) + require.True(t, initBal.Equal(userDBal)) + + // Read relayer config from disk, configure memo limit, & write config back to disk. + relayer := r.(*relayertest.Relayer) + + cfg := relayer.Sys().MustGetConfig(t) + + cfg.Global.ICS20MemoLimit = 10 + + cfgOutput := new(cmd.ConfigOutputWrapper) + cfgOutput.ProviderConfigs = cmd.ProviderConfigs{} + cfgOutput.Global = cfg.Global + cfgOutput.Paths = cfg.Paths + + for _, c := range cfg.ProviderConfigs { + stuff := c.Value.(*cosmos.CosmosProviderConfig) + + cfgOutput.ProviderConfigs[stuff.ChainID] = &cmd.ProviderConfigWrapper{ + Type: "cosmos", + Value: stuff, + } + } + + cfgBz, err := yaml.Marshal(cfgOutput) + require.NoError(t, err) + + err = relayer.Sys().WriteConfig(t, cfgBz) + require.NoError(t, err) + + err = r.StartRelayer(ctx, eRep, pathName) + require.NoError(t, err) + + t.Cleanup( + func() { + err := r.StopRelayer(ctx, eRep) + if err != nil { + t.Logf("an error occurred while stopping the relayer: %s", err) + } + }, + ) + + // Send transfers that should succeed & assert balances. + channels, err := r.GetChannels(ctx, eRep, chainA.Config().ChainID) + require.NoError(t, err) + require.Equal(t, 1, len(channels)) + + channel := channels[0] + + transferAmount := sdkmath.NewInt(1_000) + + transferAB := ibc.WalletAmount{ + Address: userB.FormattedAddress(), + Denom: chainA.Config().Denom, + Amount: transferAmount, + } + + transferCD := ibc.WalletAmount{ + Address: userD.FormattedAddress(), + Denom: chainA.Config().Denom, + Amount: transferAmount, + } + + _, err = chainA.SendIBCTransfer(ctx, channel.ChannelID, userA.KeyName(), transferAB, ibc.TransferOptions{}) + require.NoError(t, err) + + _, err = chainA.SendIBCTransfer(ctx, channel.ChannelID, userC.KeyName(), transferCD, ibc.TransferOptions{}) + require.NoError(t, err) + + require.NoError(t, testutil.WaitForBlocks(ctx, 5, chainA, chainB)) + + // Compose the ibc denom for balance assertions on the counterparty and assert balances. + denom := transfertypes.GetPrefixedDenom( + channel.Counterparty.PortID, + channel.Counterparty.ChannelID, + chainA.Config().Denom, + ) + trace := transfertypes.ParseDenomTrace(denom) + + userABal, err = chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom) + require.NoError(t, err) + require.True(t, userABal.Equal(initBal.Sub(transferAmount))) + + userBBal, err = chainB.GetBalance(ctx, userB.FormattedAddress(), trace.IBCDenom()) + require.NoError(t, err) + require.True(t, userBBal.Equal(transferAmount)) + + userCBal, err = chainA.GetBalance(ctx, userC.FormattedAddress(), chainA.Config().Denom) + require.NoError(t, err) + require.True(t, userCBal.Equal(initBal.Sub(transferAmount))) + + userDBal, err = chainB.GetBalance(ctx, userD.FormattedAddress(), trace.IBCDenom()) + require.NoError(t, err) + require.True(t, userDBal.Equal(transferAmount)) + + // Send transfer with memo that exceeds limit, ensure transfer failed and assert balances. + opts := ibc.TransferOptions{ + Memo: "this memo is too long", + Timeout: &ibc.IBCTimeout{ + Height: 10, + }, + } + + _, err = chainA.SendIBCTransfer(ctx, channel.ChannelID, userA.KeyName(), transferAB, opts) + require.NoError(t, err) + + require.NoError(t, testutil.WaitForBlocks(ctx, 11, chainA, chainB)) + + userABal, err = chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom) + require.NoError(t, err) + require.True(t, !userABal.Equal(initBal.Sub(transferAmount))) + + userBBal, err = chainB.GetBalance(ctx, userB.FormattedAddress(), trace.IBCDenom()) + require.NoError(t, err) + require.True(t, userBBal.Equal(transferAmount)) + + // Send transfer with receiver field that exceeds limit, ensure transfer failed and assert balances. + var junkReceiver string + + for i := 0; i < 130; i++ { + junkReceiver += "a" + } + + transferCD = ibc.WalletAmount{ + Address: junkReceiver, + Denom: chainA.Config().Denom, + Amount: transferAmount, + } + + _, err = chainA.SendIBCTransfer(ctx, channel.ChannelID, userC.KeyName(), transferCD, ibc.TransferOptions{}) + require.NoError(t, err) + + require.NoError(t, testutil.WaitForBlocks(ctx, 5, chainA, chainB)) + + userCBal, err = chainA.GetBalance(ctx, userC.FormattedAddress(), chainA.Config().Denom) + require.NoError(t, err) + require.True(t, !userCBal.Equal(initBal.Sub(transferAmount))) + + userDBal, err = chainB.GetBalance(ctx, userD.FormattedAddress(), trace.IBCDenom()) + require.NoError(t, err) + require.True(t, userDBal.Equal(transferAmount)) +} diff --git a/interchaintest/misbehaviour_test.go b/interchaintest/misbehaviour_test.go index 9c99c5504..5714b5de4 100644 --- a/interchaintest/misbehaviour_test.go +++ b/interchaintest/misbehaviour_test.go @@ -8,6 +8,7 @@ import ( "testing" "time" + sdkmath "cosmossdk.io/math" simappparams "cosmossdk.io/simapp/params" "github.com/cometbft/cometbft/crypto/tmhash" cometproto "github.com/cometbft/cometbft/proto/tendermint/types" @@ -20,20 +21,19 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" "github.com/cosmos/gogoproto/proto" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - "github.com/cosmos/ibc-go/v7/modules/core/exported" - ibctypes "github.com/cosmos/ibc-go/v7/modules/core/types" - ibccomettypes "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" - ibctesting "github.com/cosmos/ibc-go/v7/testing" - ibcmocks "github.com/cosmos/ibc-go/v7/testing/mock" - "github.com/cosmos/ibc-go/v7/testing/simapp" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + "github.com/cosmos/ibc-go/v8/modules/core/exported" + ibctypes "github.com/cosmos/ibc-go/v8/modules/core/types" + ibccomettypes "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" + ibctesting "github.com/cosmos/ibc-go/v8/testing" + ibcmocks "github.com/cosmos/ibc-go/v8/testing/mock" relayertest "github.com/cosmos/relayer/v2/interchaintest" - "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap" "go.uber.org/zap/zaptest" @@ -49,9 +49,21 @@ func TestRelayerMisbehaviourDetection(t *testing.T) { logger := zaptest.NewLogger(t) cf := interchaintest.NewBuiltinChainFactory(logger, []*interchaintest.ChainSpec{ - {Name: "gaia", Version: "v9.0.0-rc1", NumValidators: &numVals, NumFullNodes: &numFullNodes, ChainConfig: ibc.ChainConfig{ChainID: "chain-a", GasPrices: "0.0uatom", Bech32Prefix: "cosmos"}}, - {Name: "gaia", Version: "v9.0.0-rc1", NumValidators: &numVals, NumFullNodes: &numFullNodes, ChainConfig: ibc.ChainConfig{ChainID: "chain-b", GasPrices: "0.0uatom", Bech32Prefix: "cosmos"}}}, - ) + { + Name: "gaia", + Version: "v14.1.0", + NumValidators: &numVals, + NumFullNodes: &numFullNodes, + ChainConfig: ibc.ChainConfig{ChainID: "chain-a", GasPrices: "0.0uatom", Bech32Prefix: "cosmos"}, + }, + { + Name: "gaia", + Version: "v14.1.0", + NumValidators: &numVals, + NumFullNodes: &numFullNodes, + ChainConfig: ibc.ChainConfig{ChainID: "chain-b", GasPrices: "0.0uatom", Bech32Prefix: "cosmos"}, + }, + }) chains, err := cf.Chains(t.Name()) require.NoError(t, err) @@ -94,7 +106,8 @@ func TestRelayerMisbehaviourDetection(t *testing.T) { }) // create a new user account and wait a few blocks for it to be created on chain - user := interchaintest.GetAndFundTestUsers(t, ctx, "user-1", 10_000_000, chainA)[0] + initBal := sdkmath.NewInt(10_000_000) + user := interchaintest.GetAndFundTestUsers(t, ctx, "user-1", initBal, chainA)[0] err = testutil.WaitForBlocks(ctx, 5, chainA) require.NoError(t, err) @@ -292,9 +305,8 @@ func createTMClientHeader( hhash := tmHeader.Hash() blockID := ibctesting.MakeBlockID(hhash, 3, tmhash.Sum([]byte("part_set"))) - voteSet := comettypes.NewVoteSet(chainID, blockHeight, 1, cometproto.PrecommitType, tmValSet) - commit, err := comettypes.MakeCommit(blockID, blockHeight, 1, voteSet, signers, timestamp) + commit, err := MakeCommit(blockID, blockHeight, 1, tmValSet, signers, chainID, timestamp) require.NoError(t, err) signedHeader := &cometproto.SignedHeader{ @@ -328,8 +340,6 @@ func defaultEncoding() simappparams.EncodingConfig { cfg := simappparams.MakeTestEncodingConfig() std.RegisterLegacyAminoCodec(cfg.Amino) std.RegisterInterfaces(cfg.InterfaceRegistry) - simapp.ModuleBasics.RegisterLegacyAminoCodec(cfg.Amino) - simapp.ModuleBasics.RegisterInterfaces(cfg.InterfaceRegistry) banktypes.RegisterInterfaces(cfg.InterfaceRegistry) ibctypes.RegisterInterfaces(cfg.InterfaceRegistry) @@ -338,3 +348,53 @@ func defaultEncoding() simappparams.EncodingConfig { return cfg } + +func MakeCommit(blockID comettypes.BlockID, height int64, round int32, valSet *comettypes.ValidatorSet, privVals []comettypes.PrivValidator, chainID string, now time.Time) (*comettypes.Commit, error) { + sigs := make([]comettypes.CommitSig, len(valSet.Validators)) + for i := 0; i < len(valSet.Validators); i++ { + sigs[i] = comettypes.NewCommitSigAbsent() + } + + for _, privVal := range privVals { + pk, err := privVal.GetPubKey() + if err != nil { + return nil, err + } + addr := pk.Address() + + idx, _ := valSet.GetByAddress(addr) + if idx < 0 { + return nil, fmt.Errorf("validator with address %s not in validator set", addr) + } + + vote := &comettypes.Vote{ + ValidatorAddress: addr, + ValidatorIndex: idx, + Height: height, + Round: round, + Type: cometproto.PrecommitType, + BlockID: blockID, + Timestamp: now, + } + + v := vote.ToProto() + + if err := privVal.SignVote(chainID, v); err != nil { + return nil, err + } + + sigs[idx] = comettypes.CommitSig{ + BlockIDFlag: comettypes.BlockIDFlagCommit, + ValidatorAddress: addr, + Timestamp: now, + Signature: v.Signature, + } + } + + return &comettypes.Commit{ + Height: height, + Round: round, + BlockID: blockID, + Signatures: sigs, + }, nil +} diff --git a/interchaintest/multi_channel_test.go b/interchaintest/multi_channel_test.go index ad123f756..e1fe87eca 100644 --- a/interchaintest/multi_channel_test.go +++ b/interchaintest/multi_channel_test.go @@ -4,15 +4,16 @@ import ( "context" "testing" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" + sdkmath "cosmossdk.io/math" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v7/relayer" - interchaintestrly "github.com/strangelove-ventures/interchaintest/v7/relayer/rly" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v8/relayer" + interchaintestrly "github.com/strangelove-ventures/interchaintest/v8/relayer/rly" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) @@ -33,13 +34,13 @@ func TestMultipleChannelsOneConnection(t *testing.T) { { Name: "gaia", ChainName: "gaia", - Version: "v7.0.3", + Version: "v14.1.0", ChainConfig: ibc.ChainConfig{GasPrices: "0.00atom"}, }, { Name: "osmosis", ChainName: "osmosis", - Version: "v11.0.1", + Version: "v22.0.0", ChainConfig: ibc.ChainConfig{GasPrices: "0.00osmo"}, }, }) @@ -79,8 +80,8 @@ func TestMultipleChannelsOneConnection(t *testing.T) { }) // Create user accounts on both chains - const initFunds = int64(10_000_000) - users := interchaintest.GetAndFundTestUsers(t, ctx, "user-key", initFunds, gaia, osmosis) + initBal := sdkmath.NewInt(10_000_000) + users := interchaintest.GetAndFundTestUsers(t, ctx, "user-key", initBal, gaia, osmosis) gaiaUser, osmosisUser := users[0], users[1] @@ -122,7 +123,7 @@ func TestMultipleChannelsOneConnection(t *testing.T) { require.Equal(t, 3, len(channels)) // Send an IBC transfer across all three channels - const transferAmount = int64(1000) + transferAmount := sdkmath.NewInt(1000) transfer := ibc.WalletAmount{ Address: osmosisUser.FormattedAddress(), Denom: gaia.Config().Denom, @@ -146,15 +147,16 @@ func TestMultipleChannelsOneConnection(t *testing.T) { ibcDenoms[2] = transfertypes.ParseDenomTrace(transfertypes.GetPrefixedDenom(channels[2].Counterparty.PortID, channels[2].Counterparty.ChannelID, gaia.Config().Denom)) // Assert that the transfers are all successful out of the src chain account + expectedBal := initBal.Sub(transferAmount.MulRaw(3)) nativeGaiaBal, err := gaia.GetBalance(ctx, gaiaUser.FormattedAddress(), gaia.Config().Denom) require.NoError(t, err) - require.Equal(t, initFunds-transferAmount*3, nativeGaiaBal) + require.True(t, expectedBal.Equal(nativeGaiaBal)) // Assert that the transfers are all successful on the dst chain account for _, denom := range ibcDenoms { balance, err := osmosis.GetBalance(ctx, osmosisUser.FormattedAddress(), denom.IBCDenom()) require.NoError(t, err) - require.Equal(t, transferAmount, balance) + require.True(t, transferAmount.Equal(balance)) } // Send the funds back to the original source chain @@ -176,13 +178,13 @@ func TestMultipleChannelsOneConnection(t *testing.T) { // Assert that the transfers are all successful back on the original src chain account nativeGaiaBal, err = gaia.GetBalance(ctx, gaiaUser.FormattedAddress(), gaia.Config().Denom) require.NoError(t, err) - require.Equal(t, initFunds, nativeGaiaBal) + require.True(t, nativeGaiaBal.Equal(initBal)) // Assert that the transfers are all successfully sent back to the original src chain account for _, denom := range ibcDenoms { balance, err := osmosis.GetBalance(ctx, osmosisUser.FormattedAddress(), denom.IBCDenom()) require.NoError(t, err) - require.Equal(t, int64(0), balance) + require.True(t, sdkmath.ZeroInt().Equal(balance)) } } diff --git a/interchaintest/path_filter_test.go b/interchaintest/path_filter_test.go index 3ef7b9215..93506bd6a 100644 --- a/interchaintest/path_filter_test.go +++ b/interchaintest/path_filter_test.go @@ -5,15 +5,16 @@ import ( "fmt" "testing" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" + sdkmath "cosmossdk.io/math" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" "github.com/cosmos/relayer/v2/relayer" "github.com/cosmos/relayer/v2/relayer/processor" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" "golang.org/x/sync/errgroup" @@ -28,8 +29,8 @@ func TestScenarioPathFilterAllow(t *testing.T) { // Chain Factory cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ - {Name: "gaia", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf}, - {Name: "osmosis", Version: "v11.0.1", NumValidators: &nv, NumFullNodes: &nf}, + {Name: "gaia", Version: "v14.1.0", NumValidators: &nv, NumFullNodes: &nf}, + {Name: "osmosis", Version: "v22.0.0", NumValidators: &nv, NumFullNodes: &nf}, }) chains, err := cf.Chains(t.Name()) @@ -84,8 +85,8 @@ func TestScenarioPathFilterAllow(t *testing.T) { }) // Create and Fund User Wallets - fundAmount := int64(10_000_000) - users := interchaintest.GetAndFundTestUsers(t, ctx, "default", int64(fundAmount), gaia, osmosis) + initBal := sdkmath.NewInt(10_000_000) + users := interchaintest.GetAndFundTestUsers(t, ctx, "default", initBal, gaia, osmosis) gaiaUser, osmosisUser := users[0].(*cosmos.CosmosWallet), users[1].(*cosmos.CosmosWallet) @@ -100,7 +101,7 @@ func TestScenarioPathFilterAllow(t *testing.T) { ) // Send Transaction - amountToSend := int64(1_000_000) + amountToSend := sdkmath.NewInt(1_000_000) gaiaDstAddress := gaiaUser.FormattedAddressWithPrefix(osmosis.Config().Bech32Prefix) osmosisDstAddress := osmosisUser.FormattedAddressWithPrefix(gaia.Config().Bech32Prefix) @@ -159,11 +160,11 @@ func TestScenarioPathFilterAllow(t *testing.T) { // Test destination wallets have increased funds gaiaIBCBalance, err := osmosis.GetBalance(ctx, gaiaDstAddress, gaiaIbcDenom) require.NoError(t, err) - require.Equal(t, amountToSend, gaiaIBCBalance) + require.True(t, amountToSend.Equal(gaiaIBCBalance)) osmosisIBCBalance, err := gaia.GetBalance(ctx, osmosisDstAddress, osmosisIbcDenom) require.NoError(t, err) - require.Equal(t, amountToSend, osmosisIBCBalance) + require.True(t, amountToSend.Equal(osmosisIBCBalance)) } // TestScenarioPathFilterDeny tests the channel denylist @@ -175,8 +176,8 @@ func TestScenarioPathFilterDeny(t *testing.T) { // Chain Factory cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ - {Name: "gaia", Version: "v7.0.3", NumValidators: &nv, NumFullNodes: &nf}, - {Name: "osmosis", Version: "v11.0.1", NumValidators: &nv, NumFullNodes: &nf}, + {Name: "gaia", Version: "v14.1.0", NumValidators: &nv, NumFullNodes: &nf}, + {Name: "osmosis", Version: "v22.0.0", NumValidators: &nv, NumFullNodes: &nf}, }) chains, err := cf.Chains(t.Name()) @@ -230,8 +231,8 @@ func TestScenarioPathFilterDeny(t *testing.T) { }) // Create and Fund User Wallets - fundAmount := int64(10_000_000) - users := interchaintest.GetAndFundTestUsers(t, ctx, "default", int64(fundAmount), gaia, osmosis) + initBal := sdkmath.NewInt(10_000_000) + users := interchaintest.GetAndFundTestUsers(t, ctx, "default", initBal, gaia, osmosis) gaiaUser, osmosisUser := users[0].(*cosmos.CosmosWallet), users[1].(*cosmos.CosmosWallet) @@ -246,7 +247,7 @@ func TestScenarioPathFilterDeny(t *testing.T) { ) // Send Transaction - amountToSend := int64(1_000_000) + amountToSend := sdkmath.NewInt(1_000_000) gaiaDstAddress := gaiaUser.FormattedAddressWithPrefix(osmosis.Config().Bech32Prefix) osmosisDstAddress := osmosisUser.FormattedAddressWithPrefix(gaia.Config().Bech32Prefix) @@ -317,9 +318,9 @@ func TestScenarioPathFilterDeny(t *testing.T) { // Test destination wallets do not have increased funds gaiaIBCBalance, err := osmosis.GetBalance(ctx, gaiaDstAddress, gaiaIbcDenom) require.NoError(t, err) - require.Equal(t, int64(0), gaiaIBCBalance) + require.True(t, sdkmath.ZeroInt().Equal(gaiaIBCBalance)) osmosisIBCBalance, err := gaia.GetBalance(ctx, osmosisDstAddress, osmosisIbcDenom) require.NoError(t, err) - require.Equal(t, int64(0), osmosisIBCBalance) + require.True(t, sdkmath.ZeroInt().Equal(osmosisIBCBalance)) } diff --git a/interchaintest/poll_test.go b/interchaintest/poll_test.go deleted file mode 100644 index 2c54579f9..000000000 --- a/interchaintest/poll_test.go +++ /dev/null @@ -1,56 +0,0 @@ -package interchaintest_test - -import ( - "context" - "errors" - - rpchttp "github.com/cometbft/cometbft/rpc/client/http" - "github.com/cosmos/cosmos-sdk/codec" - codectypes "github.com/cosmos/cosmos-sdk/codec/types" - sdk "github.com/cosmos/cosmos-sdk/types" - authTx "github.com/cosmos/cosmos-sdk/x/auth/tx" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testutil" -) - -// TODO: Once relayer updated for ibc-go/v7, replace with interchaintest's cosmos.PollForMessage function. -func pollForUpdateClient(ctx context.Context, chain ibc.Chain, startHeight, maxHeight uint64) (*clienttypes.MsgUpdateClient, error) { - const secondsTimeout uint = 30 - c, err := rpchttp.NewWithTimeout(chain.GetHostRPCAddress(), "/websocket", secondsTimeout) - if err != nil { - panic(err) - } - - doPoll := func(ctx context.Context, height uint64) (*clienttypes.MsgUpdateClient, error) { - h := int64(height) - block, err := c.Block(ctx, &h) - if err != nil { - return nil, err - } - for _, tx := range block.Block.Txs { - sdkTx, err := decodeTX(chain.Config().EncodingConfig.InterfaceRegistry, tx) - if err != nil { - return nil, err - } - for _, msg := range sdkTx.GetMsgs() { - if found, ok := msg.(*clienttypes.MsgUpdateClient); ok { - return found, nil - } - } - } - return nil, errors.New("not found") - } - - bp := testutil.BlockPoller[*clienttypes.MsgUpdateClient]{CurrentHeight: chain.Height, PollFunc: doPoll} - result, err := bp.DoPoll(ctx, startHeight, maxHeight) - if err != nil { - return nil, err - } - return result, nil -} - -func decodeTX(interfaceRegistry codectypes.InterfaceRegistry, txbz []byte) (sdk.Tx, error) { - cdc := codec.NewProtoCodec(interfaceRegistry) - return authTx.DefaultTxDecoder(cdc)(txbz) -} diff --git a/interchaintest/relay_many_test.go b/interchaintest/relay_many_test.go index 65859f487..384604ab8 100644 --- a/interchaintest/relay_many_test.go +++ b/interchaintest/relay_many_test.go @@ -4,13 +4,14 @@ import ( "context" "testing" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" + sdkmath "cosmossdk.io/math" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" - "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" "golang.org/x/sync/errgroup" @@ -34,14 +35,14 @@ func TestRelayerMultiplePathsSingleProcess(t *testing.T) { { Name: "gaia", ChainName: "gaia", - Version: "v7.0.3", + Version: "v14.1.0", NumValidators: &nv, NumFullNodes: &nf, }, { Name: "osmosis", ChainName: "osmosis", - Version: "v11.0.1", + Version: "v22.0.0", NumValidators: &nv, NumFullNodes: &nf, }, @@ -112,8 +113,8 @@ func TestRelayerMultiplePathsSingleProcess(t *testing.T) { ) // Fund user accounts, so we can query balances and make assertions. - const userFunds = int64(10_000_000) - users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), userFunds, gaia, osmosis, juno) + initBal := sdkmath.NewInt(10_000_000) + users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), initBal, gaia, osmosis, juno) gaiaUser, osmosisUser, junoUser := users[0].(*cosmos.CosmosWallet), users[1].(*cosmos.CosmosWallet), users[2].(*cosmos.CosmosWallet) // Wait a few blocks for user accounts to be created on chain. @@ -141,7 +142,7 @@ func TestRelayerMultiplePathsSingleProcess(t *testing.T) { var eg errgroup.Group - const transferAmount = int64(1_000_000) + transferAmount := sdkmath.NewInt(1_000_000) eg.Go(func() error { osmosisHeight, err := osmosis.Height(ctx) @@ -183,11 +184,9 @@ func TestRelayerMultiplePathsSingleProcess(t *testing.T) { osmosisOnGaiaBalance, err := gaia.GetBalance(ctx, gaiaAddress, osmosisIBCDenom) require.NoError(t, err) - - require.Equal(t, transferAmount, osmosisOnGaiaBalance) + require.True(t, transferAmount.Equal(osmosisOnGaiaBalance)) junoOnGaiaBalance, err := gaia.GetBalance(ctx, gaiaAddress, junoIBCDenom) require.NoError(t, err) - - require.Equal(t, transferAmount, junoOnGaiaBalance) + require.True(t, transferAmount.Equal(junoOnGaiaBalance)) } diff --git a/interchaintest/relayer.go b/interchaintest/relayer.go index 8641830bc..025221516 100644 --- a/interchaintest/relayer.go +++ b/interchaintest/relayer.go @@ -15,9 +15,9 @@ import ( "github.com/cosmos/relayer/v2/relayer" "github.com/cosmos/relayer/v2/relayer/chains/cosmos" "github.com/cosmos/relayer/v2/relayer/provider" - interchaintestcosmos "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/relayer/rly" + interchaintestcosmos "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/relayer/rly" "go.uber.org/zap" "go.uber.org/zap/zaptest" ) @@ -33,7 +33,7 @@ type Relayer struct { cancel context.CancelFunc } -// Build returns a relayer interface +// NewRelayer returns a relayer interface func NewRelayer( t *testing.T, config RelayerConfig, @@ -47,7 +47,7 @@ func NewRelayer( config: config, } - res := r.sys().Run(zaptest.NewLogger(t), "config", "init", "--memo", config.Memo) + res := r.Sys().Run(zaptest.NewLogger(t), "config", "init", "--memo", config.Memo) if res.Err != nil { t.Fatalf("failed to rly config init: %v", res.Err) } @@ -55,7 +55,7 @@ func NewRelayer( return r } -func (r *Relayer) sys() *relayertest.System { +func (r *Relayer) Sys() *relayertest.System { return &relayertest.System{HomeDir: r.home} } @@ -63,7 +63,7 @@ func (r *Relayer) log() *zap.Logger { return zaptest.NewLogger(r.t) } -func (r *Relayer) AddChainConfiguration(ctx context.Context, _ ibc.RelayerExecReporter, chainConfig ibc.ChainConfig, keyName, rpcAddr, grpcAddr string) error { +func (r *Relayer) AddChainConfiguration(_ context.Context, _ ibc.RelayerExecReporter, chainConfig ibc.ChainConfig, keyName, rpcAddr, _ string) error { sys := &relayertest.System{HomeDir: r.home} sys.MustAddChain(r.t, chainConfig.ChainID, cmd.ProviderConfigWrapper{ Type: "cosmos", @@ -89,7 +89,7 @@ func (r *Relayer) AddChainConfiguration(ctx context.Context, _ ibc.RelayerExecRe } func (r *Relayer) AddKey(ctx context.Context, _ ibc.RelayerExecReporter, chainID, keyName, coinType string) (ibc.Wallet, error) { - res := r.sys().RunC(ctx, r.log(), "keys", "add", chainID, keyName, "--coin-type", coinType) + res := r.Sys().RunC(ctx, r.log(), "keys", "add", chainID, keyName, "--coin-type", coinType) if res.Err != nil { return nil, res.Err } @@ -103,7 +103,7 @@ func (r *Relayer) AddKey(ctx context.Context, _ ibc.RelayerExecReporter, chainID } func (r *Relayer) RestoreKey(ctx context.Context, _ ibc.RelayerExecReporter, cfg ibc.ChainConfig, keyName, mnemonic string) error { - res := r.sys().RunC(ctx, r.log(), "keys", "restore", cfg.ChainID, keyName, mnemonic, "--coin-type", cfg.CoinType) + res := r.Sys().RunC(ctx, r.log(), "keys", "restore", cfg.ChainID, keyName, mnemonic, "--coin-type", cfg.CoinType) if res.Err != nil { return res.Err } @@ -111,7 +111,7 @@ func (r *Relayer) RestoreKey(ctx context.Context, _ ibc.RelayerExecReporter, cfg } func (r *Relayer) GeneratePath(ctx context.Context, _ ibc.RelayerExecReporter, srcChainID, dstChainID, pathName string) error { - res := r.sys().RunC(ctx, r.log(), "paths", "new", srcChainID, dstChainID, pathName) + res := r.Sys().RunC(ctx, r.log(), "paths", "new", srcChainID, dstChainID, pathName) if res.Err != nil { return res.Err } @@ -119,7 +119,7 @@ func (r *Relayer) GeneratePath(ctx context.Context, _ ibc.RelayerExecReporter, s } func (r *Relayer) UpdatePath(ctx context.Context, _ ibc.RelayerExecReporter, pathName string, filter ibc.ChannelFilter) error { - res := r.sys().RunC(ctx, r.log(), "paths", "update", pathName, + res := r.Sys().RunC(ctx, r.log(), "paths", "update", pathName, "--filter-rule", filter.Rule, "--filter-channels", strings.Join(filter.ChannelList, ","), ) @@ -130,7 +130,7 @@ func (r *Relayer) UpdatePath(ctx context.Context, _ ibc.RelayerExecReporter, pat } func (r *Relayer) GetChannels(ctx context.Context, _ ibc.RelayerExecReporter, chainID string) ([]ibc.ChannelOutput, error) { - res := r.sys().RunC(ctx, r.log(), "q", "channels", chainID) + res := r.Sys().RunC(ctx, r.log(), "q", "channels", chainID) if res.Err != nil { return nil, res.Err } @@ -151,7 +151,7 @@ func (r *Relayer) GetChannels(ctx context.Context, _ ibc.RelayerExecReporter, ch } func (r *Relayer) GetClients(ctx context.Context, _ ibc.RelayerExecReporter, chainID string) (ibc.ClientOutputs, error) { - res := r.sys().RunC(ctx, r.log(), "q", "clients", chainID) + res := r.Sys().RunC(ctx, r.log(), "q", "clients", chainID) if res.Err != nil { return nil, res.Err } @@ -172,7 +172,7 @@ func (r *Relayer) GetClients(ctx context.Context, _ ibc.RelayerExecReporter, cha } func (r *Relayer) LinkPath(ctx context.Context, _ ibc.RelayerExecReporter, pathName string, chanOpts ibc.CreateChannelOptions, clientOpts ibc.CreateClientOptions) error { - res := r.sys().RunC(ctx, r.log(), "tx", "link", pathName, + res := r.Sys().RunC(ctx, r.log(), "tx", "link", pathName, "--src-port", chanOpts.SourcePortName, "--dst-port", chanOpts.DestPortName, "--order", chanOpts.Order.String(), @@ -186,7 +186,7 @@ func (r *Relayer) LinkPath(ctx context.Context, _ ibc.RelayerExecReporter, pathN } func (r *Relayer) GetConnections(ctx context.Context, _ ibc.RelayerExecReporter, chainID string) (ibc.ConnectionOutputs, error) { - res := r.sys().RunC(ctx, r.log(), "q", "connections", chainID) + res := r.Sys().RunC(ctx, r.log(), "q", "connections", chainID) if res.Err != nil { return nil, res.Err } @@ -214,7 +214,7 @@ func (r *Relayer) GetConnections(ctx context.Context, _ ibc.RelayerExecReporter, } func (r *Relayer) CreateChannel(ctx context.Context, _ ibc.RelayerExecReporter, pathName string, opts ibc.CreateChannelOptions) error { - res := r.sys().RunC( + res := r.Sys().RunC( ctx, r.log(), "tx", "channel", pathName, "--src-port", opts.SourcePortName, @@ -229,7 +229,7 @@ func (r *Relayer) CreateChannel(ctx context.Context, _ ibc.RelayerExecReporter, } func (r *Relayer) CreateConnections(ctx context.Context, _ ibc.RelayerExecReporter, pathName string) error { - res := r.sys().RunC(ctx, r.log(), "tx", "connection", pathName) + res := r.Sys().RunC(ctx, r.log(), "tx", "connection", pathName) if res.Err != nil { return res.Err } @@ -237,7 +237,7 @@ func (r *Relayer) CreateConnections(ctx context.Context, _ ibc.RelayerExecReport } func (r *Relayer) CreateClients(ctx context.Context, _ ibc.RelayerExecReporter, pathName string, clientOpts ibc.CreateClientOptions) error { - res := r.sys().RunC(ctx, r.log(), "tx", "clients", pathName, "--client-tp", clientOpts.TrustingPeriod) + res := r.Sys().RunC(ctx, r.log(), "tx", "clients", pathName, "--client-tp", clientOpts.TrustingPeriod) if res.Err != nil { return res.Err } @@ -245,7 +245,7 @@ func (r *Relayer) CreateClients(ctx context.Context, _ ibc.RelayerExecReporter, } func (r *Relayer) UpdateClients(ctx context.Context, _ ibc.RelayerExecReporter, pathName string) error { - res := r.sys().RunC(ctx, r.log(), "tx", "update-clients", pathName) + res := r.Sys().RunC(ctx, r.log(), "tx", "update-clients", pathName) if res.Err != nil { return res.Err } @@ -290,7 +290,7 @@ func (r *Relayer) start(ctx context.Context, remainingArgs ...string) { // It won't be reachable without introspecting the output, // but this will allow catching any possible data races around the debug server. args := append([]string{"start", "--debug-addr", "localhost:0"}, remainingArgs...) - res := r.sys().RunC(ctx, r.log(), args...) + res := r.Sys().RunC(ctx, r.log(), args...) if res.Err != nil { r.errCh <- res.Err return @@ -300,11 +300,11 @@ func (r *Relayer) start(ctx context.Context, remainingArgs ...string) { func (r *Relayer) UseDockerNetwork() bool { return false } -func (r *Relayer) Exec(ctx context.Context, _ ibc.RelayerExecReporter, cmd, env []string) ibc.RelayerExecResult { +func (r *Relayer) Exec(ctx context.Context, _ ibc.RelayerExecReporter, cmd, _ []string) ibc.RelayerExecResult { // TODO: env would be ignored for now. // We may want to modify the call to sys() to accept environment overrides, // so this relayer can continue to be used in parallel without environment cross-contamination. - res := r.sys().RunC(ctx, r.log(), cmd...) + res := r.Sys().RunC(ctx, r.log(), cmd...) exitCode := 0 if res.Err != nil { @@ -327,7 +327,7 @@ func (r *Relayer) Flush(ctx context.Context, _ ibc.RelayerExecReporter, pathName cmd = append(cmd, channelID) } } - res := r.sys().RunC(ctx, r.log(), cmd...) + res := r.Sys().RunC(ctx, r.log(), cmd...) if res.Err != nil { return res.Err } @@ -335,14 +335,14 @@ func (r *Relayer) Flush(ctx context.Context, _ ibc.RelayerExecReporter, pathName } func (r *Relayer) GetWallet(chainID string) (ibc.Wallet, bool) { - res := r.sys().RunC(context.Background(), r.log(), "keys", "show", chainID) + res := r.Sys().RunC(context.Background(), r.log(), "keys", "show", chainID) if res.Err != nil { return &interchaintestcosmos.CosmosWallet{}, false } address := strings.TrimSpace(res.Stdout.String()) var keyName string - config := r.sys().MustGetConfig(r.t) + config := r.Sys().MustGetConfig(r.t) for _, v := range config.ProviderConfigs { if c, ok := v.Value.(cosmos.CosmosProviderConfig); ok { if c.ChainID == chainID { @@ -359,3 +359,13 @@ func (r *Relayer) SetClientContractHash(ctx context.Context, rep ibc.RelayerExec //TODO implement me panic("implement me") } + +func (r *Relayer) PauseRelayer(ctx context.Context) error { + //TODO implement me + panic("implement me") +} + +func (r *Relayer) ResumeRelayer(ctx context.Context) error { + //TODO implement me + panic("implement me") +} diff --git a/interchaintest/relayer_factory.go b/interchaintest/relayer_factory.go index c833591bc..9c0ffe5aa 100644 --- a/interchaintest/relayer_factory.go +++ b/interchaintest/relayer_factory.go @@ -4,8 +4,9 @@ import ( "testing" "github.com/docker/docker/client" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v7/relayer" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v8/relayer" ) // RelayerFactory implements the interchaintest RelayerFactory interface. @@ -13,7 +14,7 @@ type RelayerFactory struct { config RelayerConfig } -// LocalRelayerConfig defines parameters for customizing a LocalRelayer. +// RelayerConfig defines parameters for customizing a LocalRelayer. type RelayerConfig struct { Processor string Memo string @@ -27,12 +28,9 @@ func NewRelayerFactory(config RelayerConfig) RelayerFactory { } // Build returns a relayer interface -func (rf RelayerFactory) Build( - t *testing.T, - _ *client.Client, - networkID string, -) ibc.Relayer { - return NewRelayer(t, rf.config) +func (rf RelayerFactory) Build(interchaintest.TestName, *client.Client, string) ibc.Relayer { + tst := &testing.T{} + return NewRelayer(tst, rf.config) } func (RelayerFactory) Capabilities() map[interchaintestrelayer.Capability]bool { diff --git a/interchaintest/relayer_override_test.go b/interchaintest/relayer_override_test.go index d729cc719..9c1d42b58 100644 --- a/interchaintest/relayer_override_test.go +++ b/interchaintest/relayer_override_test.go @@ -7,13 +7,13 @@ import ( "github.com/cosmos/relayer/v2/cmd" relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v7/relayer" - interchaintestrly "github.com/strangelove-ventures/interchaintest/v7/relayer/rly" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + interchaintestrelayer "github.com/strangelove-ventures/interchaintest/v8/relayer" + interchaintestrly "github.com/strangelove-ventures/interchaintest/v8/relayer/rly" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) @@ -43,12 +43,12 @@ func TestClientOverrideFlag(t *testing.T) { { Name: "gaia", ChainName: "gaia", - Version: "v7.0.3", + Version: "v14.1.0", }, { Name: "osmosis", ChainName: "osmosis", - Version: "v11.0.1", + Version: "v22.0.0", }, }) diff --git a/interchaintest/stride/setup_test.go b/interchaintest/stride/setup_test.go index b77529252..0258ddb1f 100644 --- a/interchaintest/stride/setup_test.go +++ b/interchaintest/stride/setup_test.go @@ -7,8 +7,8 @@ import ( "github.com/cosmos/cosmos-sdk/types/module/testutil" rlystride "github.com/cosmos/relayer/v2/relayer/chains/cosmos/stride" "github.com/icza/dyno" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" ) const ( diff --git a/interchaintest/stride/stride_icq_test.go b/interchaintest/stride/stride_icq_test.go index ac9a067e4..cbd414b67 100644 --- a/interchaintest/stride/stride_icq_test.go +++ b/interchaintest/stride/stride_icq_test.go @@ -5,16 +5,17 @@ import ( "encoding/json" "testing" + sdkmath "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/types" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" rlystride "github.com/cosmos/relayer/v2/relayer/chains/cosmos/stride" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/ibc" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" - "github.com/strangelove-ventures/interchaintest/v7/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" + "github.com/strangelove-ventures/interchaintest/v8/testutil" "github.com/stretchr/testify/require" "go.uber.org/zap" "go.uber.org/zap/zaptest" @@ -122,8 +123,8 @@ func TestScenarioStrideICAandICQ(t *testing.T) { logger.Info("TestScenarioStrideICAandICQ [1]") // Fund user accounts, so we can query balances and make assertions. - const userFunds = int64(10_000_000_000_000) - users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), userFunds, stride, gaia) + initBal := sdkmath.NewInt(10_000_000_000_000) + users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), initBal, stride, gaia) strideUser, gaiaUser := users[0], users[1] strideFullNode := stride.Validators[0] @@ -157,7 +158,7 @@ func TestScenarioStrideICAandICQ(t *testing.T) { err = stride.SendFunds(ctx, interchaintest.FaucetAccountKeyName, ibc.WalletAmount{ Address: strideAdminAddr, - Amount: userFunds, + Amount: initBal, Denom: strideCfg.Denom, }) require.NoError(t, err, "failed to fund stride admin account") @@ -200,7 +201,7 @@ func TestScenarioStrideICAandICQ(t *testing.T) { // Fund stride user with ibc denom atom tx, err := gaia.SendIBCTransfer(ctx, gaiaChans[0].ChannelID, gaiaUser.KeyName(), ibc.WalletAmount{ - Amount: 1_000_000_000_000, + Amount: sdkmath.NewInt(1_000_000_000_000), Denom: gaiaCfg.Denom, Address: strideAddr, }, ibc.TransferOptions{}) diff --git a/interchaintest/tendermint_v0.37_boundary_test.go b/interchaintest/tendermint_v0.37_boundary_test.go index e25790176..974480958 100644 --- a/interchaintest/tendermint_v0.37_boundary_test.go +++ b/interchaintest/tendermint_v0.37_boundary_test.go @@ -5,10 +5,10 @@ import ( "testing" relayerinterchaintest "github.com/cosmos/relayer/v2/interchaintest" - interchaintest "github.com/strangelove-ventures/interchaintest/v7" - "github.com/strangelove-ventures/interchaintest/v7/chain/cosmos" - "github.com/strangelove-ventures/interchaintest/v7/conformance" - "github.com/strangelove-ventures/interchaintest/v7/testreporter" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/conformance" + "github.com/strangelove-ventures/interchaintest/v8/testreporter" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) @@ -25,7 +25,7 @@ func TestScenarioTendermint37Boundary(t *testing.T) { { Name: "gaia", ChainName: "gaia", - Version: "v7.0.3", + Version: "v14.1.0", NumValidators: &nv, NumFullNodes: &nf, }, diff --git a/internal/relayertest/system.go b/internal/relayertest/system.go index 6b917b653..59daad624 100644 --- a/internal/relayertest/system.go +++ b/internal/relayertest/system.go @@ -139,6 +139,11 @@ func (s *System) MustGetConfig(t *testing.T) (config cmd.ConfigInputWrapper) { return config } +func (s *System) WriteConfig(t *testing.T, contents []byte) error { + t.Helper() + return os.WriteFile(filepath.Join(s.HomeDir, "config", "config.yaml"), contents, 0600) +} + // A fixed mnemonic and its resulting cosmos address, helpful for tests that need a mnemonic. const ( ZeroMnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art" diff --git a/proto/buf.gen.penumbra.yaml b/proto/buf.gen.penumbra.yaml index 781eea262..c26da88bf 100644 --- a/proto/buf.gen.penumbra.yaml +++ b/proto/buf.gen.penumbra.yaml @@ -10,4 +10,4 @@ managed: plugins: - name: gocosmos out: . - opt: plugins=grpc,Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types + opt: plugins=grpc,Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types,Mgoogle/protobuf/timestamp.proto=github.com/cosmos/gogoproto/types diff --git a/proto/ethermint/types/v1/dynamic_fee.proto b/proto/ethermint/types/v1/dynamic_fee.proto index b7e9c411e..48a2ea6cd 100644 --- a/proto/ethermint/types/v1/dynamic_fee.proto +++ b/proto/ethermint/types/v1/dynamic_fee.proto @@ -12,7 +12,7 @@ message ExtensionOptionDynamicFeeTx { // max_priority_price is the same as `max_priority_fee_per_gas` in eip-1559 // spec string max_priority_price = 1 [ - (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.customtype) = "cosmossdk.io/math.Int", (gogoproto.nullable) = false ]; } \ No newline at end of file diff --git a/relayer/chain.go b/relayer/chain.go index 6dafd2a6e..dfcf728cb 100644 --- a/relayer/chain.go +++ b/relayer/chain.go @@ -4,12 +4,12 @@ import ( "context" "encoding/json" "fmt" + "github.com/avast/retry-go/v4" "net/url" "time" - "github.com/avast/retry-go/v4" "github.com/cosmos/cosmos-sdk/crypto/hd" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" ) @@ -96,8 +96,8 @@ func (c *Chain) GetSelfVersion() uint64 { } // GetTrustingPeriod returns the trusting period for the chain -func (c *Chain) GetTrustingPeriod(ctx context.Context, overrideUnbondingPeriod time.Duration) (time.Duration, error) { - return c.ChainProvider.TrustingPeriod(ctx, overrideUnbondingPeriod) +func (c *Chain) GetTrustingPeriod(ctx context.Context, overrideUnbondingPeriod time.Duration, percentage int64) (time.Duration, error) { + return c.ChainProvider.TrustingPeriod(ctx, overrideUnbondingPeriod, percentage) } func (c *Chain) String() string { diff --git a/relayer/chains/cosmos/account.go b/relayer/chains/cosmos/account.go index a3b656352..311939589 100644 --- a/relayer/chains/cosmos/account.go +++ b/relayer/chains/cosmos/account.go @@ -25,7 +25,7 @@ func (cc *CosmosProvider) GetAccount(clientCtx client.Context, addr sdk.AccAddre // GetAccountWithHeight queries for an account given an address. Returns the // height of the query with the account. An error is returned if the query // or decoding fails. -func (cc *CosmosProvider) GetAccountWithHeight(clientCtx client.Context, addr sdk.AccAddress) (client.Account, int64, error) { +func (cc *CosmosProvider) GetAccountWithHeight(_ client.Context, addr sdk.AccAddress) (client.Account, int64, error) { var header metadata.MD address, err := cc.EncodeBech32AccAddr(addr) if err != nil { diff --git a/relayer/chains/cosmos/bech32_hack.go b/relayer/chains/cosmos/bech32_hack.go index 96bb81c9a..6bbfde67a 100644 --- a/relayer/chains/cosmos/bech32_hack.go +++ b/relayer/chains/cosmos/bech32_hack.go @@ -14,10 +14,15 @@ var sdkConfigMutex sync.Mutex // Don't use this unless you know what you're doing. // TODO: :dagger: :knife: :chainsaw: remove this function func (cc *CosmosProvider) SetSDKContext() func() { + return SetSDKConfigContext(cc.PCfg.AccountPrefix) +} + +// SetSDKContext sets the SDK config to the given bech32 prefixes +func SetSDKConfigContext(prefix string) func() { sdkConfigMutex.Lock() sdkConf := sdk.GetConfig() - sdkConf.SetBech32PrefixForAccount(cc.PCfg.AccountPrefix, cc.PCfg.AccountPrefix+"pub") - sdkConf.SetBech32PrefixForValidator(cc.PCfg.AccountPrefix+"valoper", cc.PCfg.AccountPrefix+"valoperpub") - sdkConf.SetBech32PrefixForConsensusNode(cc.PCfg.AccountPrefix+"valcons", cc.PCfg.AccountPrefix+"valconspub") + sdkConf.SetBech32PrefixForAccount(prefix, prefix+"pub") + sdkConf.SetBech32PrefixForValidator(prefix+"valoper", prefix+"valoperpub") + sdkConf.SetBech32PrefixForConsensusNode(prefix+"valcons", prefix+"valconspub") return sdkConfigMutex.Unlock } diff --git a/relayer/chains/cosmos/codec.go b/relayer/chains/cosmos/codec.go index 16cdaa16f..180c26750 100644 --- a/relayer/chains/cosmos/codec.go +++ b/relayer/chains/cosmos/codec.go @@ -1,8 +1,12 @@ package cosmos import ( + feegrant "cosmossdk.io/x/feegrant/module" + "cosmossdk.io/x/tx/signing" + "cosmossdk.io/x/upgrade" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/codec/address" "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/std" "github.com/cosmos/cosmos-sdk/types/module" @@ -12,7 +16,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/bank" "github.com/cosmos/cosmos-sdk/x/crisis" "github.com/cosmos/cosmos-sdk/x/distribution" - feegrant "github.com/cosmos/cosmos-sdk/x/feegrant/module" "github.com/cosmos/cosmos-sdk/x/gov" govclient "github.com/cosmos/cosmos-sdk/x/gov/client" "github.com/cosmos/cosmos-sdk/x/mint" @@ -20,12 +23,11 @@ import ( paramsclient "github.com/cosmos/cosmos-sdk/x/params/client" "github.com/cosmos/cosmos-sdk/x/slashing" "github.com/cosmos/cosmos-sdk/x/staking" - "github.com/cosmos/cosmos-sdk/x/upgrade" - upgradeclient "github.com/cosmos/cosmos-sdk/x/upgrade/client" + "github.com/cosmos/gogoproto/proto" "github.com/cosmos/ibc-go/modules/capability" - ibcfee "github.com/cosmos/ibc-go/v7/modules/apps/29-fee" - "github.com/cosmos/ibc-go/v7/modules/apps/transfer" - ibc "github.com/cosmos/ibc-go/v7/modules/core" + ibcfee "github.com/cosmos/ibc-go/v8/modules/apps/29-fee" + "github.com/cosmos/ibc-go/v8/modules/apps/transfer" + ibc "github.com/cosmos/ibc-go/v8/modules/core" cosmosmodule "github.com/cosmos/relayer/v2/relayer/chains/cosmos/module" "github.com/cosmos/relayer/v2/relayer/chains/cosmos/stride" @@ -43,8 +45,6 @@ var ModuleBasics = []module.AppModuleBasic{ gov.NewAppModuleBasic( []govclient.ProposalHandler{ paramsclient.ProposalHandler, - upgradeclient.LegacyProposalHandler, - upgradeclient.LegacyCancelProposalHandler, }, ), crisis.AppModuleBasic{}, @@ -69,9 +69,9 @@ type Codec struct { Amino *codec.LegacyAmino } -func MakeCodec(moduleBasics []module.AppModuleBasic, extraCodecs []string) Codec { +func MakeCodec(moduleBasics []module.AppModuleBasic, extraCodecs []string, accBech32Prefix, valBech32Prefix string) Codec { modBasic := module.NewBasicManager(moduleBasics...) - encodingConfig := MakeCodecConfig() + encodingConfig := MakeCodecConfig(accBech32Prefix, valBech32Prefix) std.RegisterLegacyAminoCodec(encodingConfig.Amino) std.RegisterInterfaces(encodingConfig.InterfaceRegistry) modBasic.RegisterLegacyAminoCodec(encodingConfig.Amino) @@ -92,9 +92,22 @@ func MakeCodec(moduleBasics []module.AppModuleBasic, extraCodecs []string) Codec return encodingConfig } -func MakeCodecConfig() Codec { - interfaceRegistry := types.NewInterfaceRegistry() +func MakeCodecConfig(accBech32Prefix, valBech32Prefix string) Codec { + interfaceRegistry, err := types.NewInterfaceRegistryWithOptions(types.InterfaceRegistryOptions{ + ProtoFiles: proto.HybridResolver, + SigningOptions: signing.Options{ + AddressCodec: address.NewBech32Codec(accBech32Prefix), + ValidatorAddressCodec: address.NewBech32Codec(valBech32Prefix), + }, + }) + if err != nil { + panic(err) + } marshaler := codec.NewProtoCodec(interfaceRegistry) + + done := SetSDKConfigContext(accBech32Prefix) + defer done() + return Codec{ InterfaceRegistry: interfaceRegistry, Marshaler: marshaler, diff --git a/relayer/chains/cosmos/cosmos_chain_processor.go b/relayer/chains/cosmos/cosmos_chain_processor.go index aa93f64ac..a88cf4f13 100644 --- a/relayer/chains/cosmos/cosmos_chain_processor.go +++ b/relayer/chains/cosmos/cosmos_chain_processor.go @@ -8,16 +8,15 @@ import ( "time" "github.com/avast/retry-go/v4" + coretypes "github.com/cometbft/cometbft/rpc/core/types" sdk "github.com/cosmos/cosmos-sdk/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + "github.com/cosmos/relayer/v2/relayer/chains" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" - - ctypes "github.com/cometbft/cometbft/rpc/core/types" - "github.com/cosmos/relayer/v2/relayer/chains" "go.uber.org/zap" "golang.org/x/sync/errgroup" ) @@ -150,7 +149,7 @@ func (ccp *CosmosChainProcessor) latestHeightWithRetry(ctx context.Context) (lat // nodeStatusWithRetry will query for the latest node status, retrying in case of failure. // It will delay by latestHeightQueryRetryDelay between attempts, up to latestHeightQueryRetries. -func (ccp *CosmosChainProcessor) nodeStatusWithRetry(ctx context.Context) (status *ctypes.ResultStatus, err error) { +func (ccp *CosmosChainProcessor) nodeStatusWithRetry(ctx context.Context) (status *coretypes.ResultStatus, err error) { return status, retry.Do(func() error { latestHeightQueryCtx, cancelLatestHeightQueryCtx := context.WithTimeout(ctx, queryTimeout) defer cancelLatestHeightQueryCtx() @@ -241,7 +240,6 @@ func (ccp *CosmosChainProcessor) Run(ctx context.Context, initialBlockHistory ui continue } persistence.latestHeight = status.SyncInfo.LatestBlockHeight - ccp.chainProvider.setCometVersion(ccp.log, status.NodeInfo.Version) break } @@ -309,12 +307,14 @@ func (ccp *CosmosChainProcessor) initializeConnectionState(ctx context.Context) // initializeChannelState will bootstrap the channelStateCache with the open channel state. func (ccp *CosmosChainProcessor) initializeChannelState(ctx context.Context) error { - ctx, cancel := context.WithTimeout(ctx, queryStateTimeout) + ctx, cancel := context.WithCancel(ctx) defer cancel() + channels, err := ccp.chainProvider.QueryChannels(ctx) if err != nil { return fmt.Errorf("error querying channels: %w", err) } + for _, ch := range channels { if len(ch.ConnectionHops) != 1 { ccp.log.Error("Found channel using multiple connection hops. Not currently supported, ignoring.", @@ -324,6 +324,7 @@ func (ccp *CosmosChainProcessor) initializeChannelState(ctx context.Context) err ) continue } + ccp.channelConnections[ch.ChannelId] = ch.ConnectionHops[0] k := processor.ChannelKey{ ChannelID: ch.ChannelId, @@ -331,8 +332,10 @@ func (ccp *CosmosChainProcessor) initializeChannelState(ctx context.Context) err CounterpartyChannelID: ch.Counterparty.ChannelId, CounterpartyPortID: ch.Counterparty.PortId, } + ccp.channelStateCache.SetOpen(k, ch.State == chantypes.OPEN, ch.Ordering) } + return nil } @@ -349,7 +352,6 @@ func (ccp *CosmosChainProcessor) queryCycle(ctx context.Context, persistence *qu } persistence.latestHeight = status.SyncInfo.LatestBlockHeight - ccp.chainProvider.setCometVersion(ccp.log, status.NodeInfo.Version) // This debug log is very noisy, but is helpful when debugging new chains. // ccp.log.Debug("Queried latest height", @@ -389,26 +391,35 @@ func (ccp *CosmosChainProcessor) queryCycle(ctx context.Context, persistence *qu chainID := ccp.chainProvider.ChainId() for i := persistence.latestQueriedBlock + 1; i <= persistence.latestHeight; i++ { - var eg errgroup.Group - var blockRes *ctypes.ResultBlockResults - var ibcHeader provider.IBCHeader + var ( + eg errgroup.Group + blockRes *coretypes.ResultBlockResults + ibcHeader provider.IBCHeader + ) + sI := i + eg.Go(func() (err error) { queryCtx, cancelQueryCtx := context.WithTimeout(ctx, blockResultsQueryTimeout) defer cancelQueryCtx() + blockRes, err = ccp.chainProvider.RPCClient.BlockResults(queryCtx, &sI) if err != nil && ccp.metrics != nil { ccp.metrics.IncBlockQueryFailure(chainID, "RPC Client") } + return err }) + eg.Go(func() (err error) { queryCtx, cancelQueryCtx := context.WithTimeout(ctx, queryTimeout) defer cancelQueryCtx() + ibcHeader, err = ccp.chainProvider.QueryIBCHeader(queryCtx, sI) if err != nil && ccp.metrics != nil { ccp.metrics.IncBlockQueryFailure(chainID, "IBC Header") } + return err }) @@ -451,15 +462,9 @@ func (ccp *CosmosChainProcessor) queryCycle(ctx context.Context, persistence *qu ibcHeaderCache[heightUint64] = latestHeader ppChanged = true - base64Encoded := ccp.chainProvider.cometLegacyEncoding + messages := chains.IbcMessagesFromEvents(ccp.log, blockRes.FinalizeBlockEvents, chainID, heightUint64) - blockMsgs := ccp.ibcMessagesFromBlockEvents( - blockRes.BeginBlockEvents, - blockRes.EndBlockEvents, - heightUint64, - base64Encoded, - ) - for _, m := range blockMsgs { + for _, m := range messages { ccp.handleMessage(ctx, m, ibcMessagesCache) } @@ -468,7 +473,8 @@ func (ccp *CosmosChainProcessor) queryCycle(ctx context.Context, persistence *qu // tx was not successful continue } - messages := chains.IbcMessagesFromEvents(ccp.log, tx.Events, chainID, heightUint64, base64Encoded) + + messages := chains.IbcMessagesFromEvents(ccp.log, tx.Events, chainID, heightUint64) for _, m := range messages { ccp.handleMessage(ctx, m, ibcMessagesCache) @@ -543,8 +549,15 @@ func (ccp *CosmosChainProcessor) CurrentBlockHeight(ctx context.Context, persist func (ccp *CosmosChainProcessor) CurrentRelayerBalance(ctx context.Context) { // memoize the current gas prices to only show metrics for "interesting" denoms + gasPrice := ccp.chainProvider.PCfg.GasPrices + if ccp.parsedGasPrices == nil { - gp, err := sdk.ParseDecCoins(ccp.chainProvider.PCfg.GasPrices) + dynamicFee := ccp.chainProvider.DynamicFee(ctx) + if dynamicFee != "" { + gasPrice = dynamicFee + } + + gp, err := sdk.ParseDecCoins(gasPrice) if err != nil { ccp.log.Error( "Failed to parse gas prices", @@ -569,11 +582,13 @@ func (ccp *CosmosChainProcessor) CurrentRelayerBalance(ctx context.Context) { zap.Error(err), ) } + // Print the relevant gas prices for _, gasDenom := range *ccp.parsedGasPrices { bal := relayerWalletBalances.AmountOf(gasDenom.Denom) + // Convert to a big float to get a float64 for metrics f, _ := big.NewFloat(0.0).SetInt(bal.BigInt()).Float64() - ccp.metrics.SetWalletBalance(ccp.chainProvider.ChainId(), ccp.chainProvider.PCfg.GasPrices, ccp.chainProvider.Key(), address, gasDenom.Denom, f) + ccp.metrics.SetWalletBalance(ccp.chainProvider.ChainId(), gasPrice, ccp.chainProvider.Key(), address, gasDenom.Denom, f) } } diff --git a/relayer/chains/cosmos/event_parser.go b/relayer/chains/cosmos/event_parser.go deleted file mode 100644 index 46745cfcd..000000000 --- a/relayer/chains/cosmos/event_parser.go +++ /dev/null @@ -1,16 +0,0 @@ -package cosmos - -import ( - abci "github.com/cometbft/cometbft/abci/types" - "github.com/cosmos/relayer/v2/relayer/chains" -) - -func (ccp *CosmosChainProcessor) ibcMessagesFromBlockEvents( - beginBlockEvents, endBlockEvents []abci.Event, - height uint64, base64Encoded bool, -) (res []chains.IbcMessage) { - chainID := ccp.chainProvider.ChainId() - res = append(res, chains.IbcMessagesFromEvents(ccp.log, beginBlockEvents, chainID, height, base64Encoded)...) - res = append(res, chains.IbcMessagesFromEvents(ccp.log, endBlockEvents, chainID, height, base64Encoded)...) - return res -} diff --git a/relayer/chains/cosmos/event_parser_test.go b/relayer/chains/cosmos/event_parser_test.go deleted file mode 100644 index bba49947d..000000000 --- a/relayer/chains/cosmos/event_parser_test.go +++ /dev/null @@ -1,364 +0,0 @@ -package cosmos - -import ( - "encoding/hex" - "testing" - - abci "github.com/cometbft/cometbft/abci/types" - sdk "github.com/cosmos/cosmos-sdk/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - "github.com/cosmos/relayer/v2/relayer/provider" - "github.com/google/go-cmp/cmp" - "github.com/stretchr/testify/require" - "go.uber.org/zap" - - "github.com/cosmos/relayer/v2/relayer/chains" -) - -func TestParsePacket(t *testing.T) { - const ( - testPacketTimeoutHeight = "1-1245" - testPacketTimeoutTimestamp = "1654033235600000000" - testPacketSequence = "1" - testPacketDataHex = "0123456789ABCDEF" - testPacketSrcChannel = "channel-0" - testPacketSrcPort = "port-0" - testPacketDstChannel = "channel-1" - testPacketDstPort = "port-1" - ) - - packetEventAttributes := []sdk.Attribute{ - { - Key: chantypes.AttributeKeySequence, - Value: testPacketSequence, - }, - { - Key: chantypes.AttributeKeyDataHex, - Value: testPacketDataHex, - }, - { - Key: chantypes.AttributeKeyTimeoutHeight, - Value: testPacketTimeoutHeight, - }, - { - Key: chantypes.AttributeKeyTimeoutTimestamp, - Value: testPacketTimeoutTimestamp, - }, - { - Key: chantypes.AttributeKeySrcChannel, - Value: testPacketSrcChannel, - }, - { - Key: chantypes.AttributeKeySrcPort, - Value: testPacketSrcPort, - }, - { - Key: chantypes.AttributeKeyDstChannel, - Value: testPacketDstChannel, - }, - { - Key: chantypes.AttributeKeyDstPort, - Value: testPacketDstPort, - }, - } - - parsed := new(chains.PacketInfo) - parsed.ParseAttrs(zap.NewNop(), packetEventAttributes) - - packetData, err := hex.DecodeString(testPacketDataHex) - require.NoError(t, err, "error decoding test packet data") - - require.Empty(t, cmp.Diff(provider.PacketInfo(*parsed), provider.PacketInfo{ - Sequence: uint64(1), - Data: packetData, - TimeoutHeight: clienttypes.Height{ - RevisionNumber: uint64(1), - RevisionHeight: uint64(1245), - }, - TimeoutTimestamp: uint64(1654033235600000000), - SourceChannel: testPacketSrcChannel, - SourcePort: testPacketSrcPort, - DestChannel: testPacketDstChannel, - DestPort: testPacketDstPort, - }), "parsed does not match expected") -} - -func TestParseClient(t *testing.T) { - const ( - testClientID1 = "test-client-id-1" - testClientConsensusHeight = "1-1023" - testClientHeader = "0123456789ABCDEF" - ) - - clientEventAttributes := []sdk.Attribute{ - { - Key: clienttypes.AttributeKeyClientID, - Value: testClientID1, - }, - { - Key: clienttypes.AttributeKeyConsensusHeight, - Value: testClientConsensusHeight, - }, - { - Key: clienttypes.AttributeKeyHeader, - Value: testClientHeader, - }, - } - - parsed := new(chains.ClientInfo) - parsed.ParseAttrs(zap.NewNop(), clientEventAttributes) - - clientHeader, err := hex.DecodeString(testClientHeader) - require.NoError(t, err, "error parsing test client header") - - require.Empty(t, cmp.Diff(*parsed, *chains.NewClientInfo( - testClientID1, - clienttypes.Height{ - RevisionNumber: uint64(1), - RevisionHeight: uint64(1023), - }, - clientHeader, - ), cmp.AllowUnexported(chains.ClientInfo{}, clienttypes.Height{})), "parsed client info does not match expected") -} - -func TestParseChannel(t *testing.T) { - const ( - testConnectionID1 = "test-connection-id-1" - testChannelID1 = "test-channel-id-1" - testPortID1 = "test-port-id-1" - testChannelID2 = "test-channel-id-2" - testPortID2 = "test-port-id-2" - ) - - channelEventAttributes := []sdk.Attribute{ - { - Key: chantypes.AttributeKeyConnectionID, - Value: testConnectionID1, - }, - { - Key: chantypes.AttributeKeyChannelID, - Value: testChannelID1, - }, - { - Key: chantypes.AttributeKeyPortID, - Value: testPortID1, - }, - { - Key: chantypes.AttributeCounterpartyChannelID, - Value: testChannelID2, - }, - { - Key: chantypes.AttributeCounterpartyPortID, - Value: testPortID2, - }, - } - - parsed := new(chains.ChannelInfo) - parsed.ParseAttrs(zap.NewNop(), channelEventAttributes) - - require.Empty(t, cmp.Diff(provider.ChannelInfo(*parsed), provider.ChannelInfo{ - ConnID: testConnectionID1, - ChannelID: testChannelID1, - PortID: testPortID1, - CounterpartyChannelID: testChannelID2, - CounterpartyPortID: testPortID2, - }), "parsed channel info does not match expected") -} - -func TestParseConnection(t *testing.T) { - const ( - testConnectionID1 = "test-connection-id-1" - testClientID1 = "test-client-id-1" - testConnectionID2 = "test-connection-id-2" - testClientID2 = "test-client-id-2" - ) - - connectionEventAttributes := []sdk.Attribute{ - { - Key: conntypes.AttributeKeyConnectionID, - Value: testConnectionID1, - }, - { - Key: conntypes.AttributeKeyClientID, - Value: testClientID1, - }, - { - Key: conntypes.AttributeKeyCounterpartyConnectionID, - Value: testConnectionID2, - }, - { - Key: conntypes.AttributeKeyCounterpartyClientID, - Value: testClientID2, - }, - } - - parsed := new(chains.ConnectionInfo) - parsed.ParseAttrs(zap.NewNop(), connectionEventAttributes) - - require.Empty(t, cmp.Diff(provider.ConnectionInfo(*parsed), provider.ConnectionInfo{ - ClientID: testClientID1, - ConnID: testConnectionID1, - CounterpartyClientID: testClientID2, - CounterpartyConnID: testConnectionID2, - }), "parsed connection info does not match expected") -} - -func TestParseEventLogs(t *testing.T) { - const ( - testClientID1 = "test-client-id-1" - testClientConsensusHeight = "1-1023" - testPacketTimeoutHeight = "1-1245" - testPacketTimeoutTimestamp = "1654033235600000000" - testPacketSequence = "1" - testPacketDataHex = "0123456789ABCDEF" - testPacketAckHex = "FBDA532947" - testPacketSrcChannel = "channel-0" - testPacketSrcPort = "port-0" - testPacketDstChannel = "channel-1" - testPacketDstPort = "port-1" - ) - events := []abci.Event{ - - { - Type: clienttypes.EventTypeUpdateClient, - Attributes: []abci.EventAttribute{ - { - Key: clienttypes.AttributeKeyClientID, - Value: testClientID1, - }, - { - Key: clienttypes.AttributeKeyConsensusHeight, - Value: testClientConsensusHeight, - }, - }, - }, - { - Type: chantypes.EventTypeRecvPacket, - Attributes: []abci.EventAttribute{ - { - Key: chantypes.AttributeKeySequence, - Value: testPacketSequence, - }, - { - Key: chantypes.AttributeKeyDataHex, - Value: testPacketDataHex, - }, - { - Key: chantypes.AttributeKeyTimeoutHeight, - Value: testPacketTimeoutHeight, - }, - { - Key: chantypes.AttributeKeyTimeoutTimestamp, - Value: testPacketTimeoutTimestamp, - }, - { - Key: chantypes.AttributeKeySrcChannel, - Value: testPacketSrcChannel, - }, - { - Key: chantypes.AttributeKeySrcPort, - Value: testPacketSrcPort, - }, - { - Key: chantypes.AttributeKeyDstChannel, - Value: testPacketDstChannel, - }, - { - Key: chantypes.AttributeKeyDstPort, - Value: testPacketDstPort, - }, - }, - }, - { - Type: chantypes.EventTypeWriteAck, - Attributes: []abci.EventAttribute{ - { - Key: chantypes.AttributeKeySequence, - Value: testPacketSequence, - }, - { - Key: chantypes.AttributeKeyAckHex, - Value: testPacketAckHex, - }, - { - Key: chantypes.AttributeKeySrcChannel, - Value: testPacketSrcChannel, - }, - { - Key: chantypes.AttributeKeySrcPort, - Value: testPacketSrcPort, - }, - { - Key: chantypes.AttributeKeyDstChannel, - Value: testPacketDstChannel, - }, - { - Key: chantypes.AttributeKeyDstPort, - Value: testPacketDstPort, - }, - }, - }, - } - - ibcMessages := chains.IbcMessagesFromEvents(zap.NewNop(), events, "", 0, false) - - require.Len(t, ibcMessages, 3) - - msgUpdateClient := ibcMessages[0] - require.Equal(t, clienttypes.EventTypeUpdateClient, msgUpdateClient.EventType) - - clientInfoParsed, isClientInfo := msgUpdateClient.Info.(*chains.ClientInfo) - require.True(t, isClientInfo, "messageInfo is not clientInfo") - - require.Empty(t, cmp.Diff(*clientInfoParsed, *chains.NewClientInfo( - testClientID1, - clienttypes.Height{ - RevisionNumber: uint64(1), - RevisionHeight: uint64(1023), - }, - nil, - ), cmp.AllowUnexported(chains.ClientInfo{}, clienttypes.Height{})), "parsed client info does not match expected") - - msgRecvPacket := ibcMessages[1] - require.Equal(t, chantypes.EventTypeRecvPacket, msgRecvPacket.EventType, "message event is not recv_packet") - - packetInfoParsed, isPacketInfo := msgRecvPacket.Info.(*chains.PacketInfo) - require.True(t, isPacketInfo, "recv_packet messageInfo is not packetInfo") - - msgWriteAcknowledgement := ibcMessages[2] - require.Equal(t, chantypes.EventTypeWriteAck, msgWriteAcknowledgement.EventType, "message event is not write_acknowledgement") - - ackPacketInfoParsed, isPacketInfo := msgWriteAcknowledgement.Info.(*chains.PacketInfo) - require.True(t, isPacketInfo, "ack messageInfo is not packetInfo") - - packetAck, err := hex.DecodeString(testPacketAckHex) - require.NoError(t, err, "error decoding test packet ack") - - packetData, err := hex.DecodeString(testPacketDataHex) - require.NoError(t, err, "error decoding test packet data") - - require.Empty(t, cmp.Diff(provider.PacketInfo(*packetInfoParsed), provider.PacketInfo{ - Sequence: uint64(1), - Data: packetData, - TimeoutHeight: clienttypes.Height{ - RevisionNumber: uint64(1), - RevisionHeight: uint64(1245), - }, - TimeoutTimestamp: uint64(1654033235600000000), - SourceChannel: testPacketSrcChannel, - SourcePort: testPacketSrcPort, - DestChannel: testPacketDstChannel, - DestPort: testPacketDstPort, - }), "parsed packet info does not match expected") - - require.Empty(t, cmp.Diff(provider.PacketInfo(*ackPacketInfoParsed), provider.PacketInfo{ - Sequence: uint64(1), - SourceChannel: testPacketSrcChannel, - SourcePort: testPacketSrcPort, - DestChannel: testPacketDstChannel, - DestPort: testPacketDstPort, - Ack: packetAck, - }), "parsed packet info does not match expected") -} diff --git a/relayer/chains/cosmos/fee_market.go b/relayer/chains/cosmos/fee_market.go new file mode 100644 index 000000000..bc4cb85f1 --- /dev/null +++ b/relayer/chains/cosmos/fee_market.go @@ -0,0 +1,79 @@ +package cosmos + +import ( + "context" + "fmt" + "regexp" + "strings" + + sdkmath "cosmossdk.io/math" + "go.uber.org/zap" +) + +const queryPath = "/osmosis.txfees.v1beta1.Query/GetEipBaseFee" + +// DynamicFee queries the dynamic gas price base fee and returns a string with the base fee and token denom concatenated. +// If the chain does not have dynamic fees enabled in the config, nothing happens and an empty string is always returned. +func (cc *CosmosProvider) DynamicFee(ctx context.Context) string { + if !cc.PCfg.DynamicGasPrice { + return "" + } + + dynamicFee, err := cc.QueryBaseFee(ctx) + if err != nil { + // If there was an error querying the dynamic base fee, do nothing and fall back to configured gas price. + cc.log.Warn("Failed to query the dynamic gas price base fee", zap.Error(err)) + return "" + } + + return dynamicFee +} + +// QueryBaseFee attempts to make an ABCI query to retrieve the base fee on chains using the Osmosis EIP-1559 implementation. +// This is currently hardcoded to only work on Osmosis. +func (cc *CosmosProvider) QueryBaseFee(ctx context.Context) (string, error) { + resp, err := cc.RPCClient.ABCIQuery(ctx, queryPath, nil) + if err != nil || resp.Response.Code != 0 { + return "", err + } + + // The response value contains the data link escape control character which must be removed before parsing. + cleanedString := strings.ReplaceAll(strings.TrimSpace(string(resp.Response.Value)), "\u0010", "") + + decFee, err := sdkmath.LegacyNewDecFromStr(cleanedString) + if err != nil { + return "", err + } + + baseFee, err := decFee.Float64() + if err != nil { + return "", err + } + + // The current EIP-1559 implementation returns an integer and does not return any value that tells us how many + // decimal places we need to account for. + // + // This may be problematic because we are assuming that we always need to move the decimal 18 places. + fee := baseFee / 1e18 + + denom, err := parseTokenDenom(cc.PCfg.GasPrices) + if err != nil { + return "", err + } + + return fmt.Sprintf("%f%s", fee, denom), nil +} + +// parseTokenDenom takes a string in the format numericGasPrice + tokenDenom (e.g. 0.0025uosmo), +// and parses the tokenDenom portion (e.g. uosmo) before returning just the token denom. +func parseTokenDenom(gasPrice string) (string, error) { + regex := regexp.MustCompile(`^0\.\d+([a-zA-Z]+)$`) + + matches := regex.FindStringSubmatch(gasPrice) + + if len(matches) != 2 { + return "", fmt.Errorf("failed to parse token denom from string %s", gasPrice) + } + + return matches[1], nil +} diff --git a/relayer/chains/cosmos/fee_market_test.go b/relayer/chains/cosmos/fee_market_test.go new file mode 100644 index 000000000..746d31ed9 --- /dev/null +++ b/relayer/chains/cosmos/fee_market_test.go @@ -0,0 +1,61 @@ +package cosmos + +import ( + "context" + "testing" + + "github.com/stretchr/testify/require" +) + +var ( + coinType = 118 + + testCfg = CosmosProviderConfig{ + KeyDirectory: "", + Key: "default", + ChainName: "osmosis", + ChainID: "osmosis-1", + RPCAddr: "https://rpc.osmosis.strange.love:443", + AccountPrefix: "osmo", + KeyringBackend: "test", + DynamicGasPrice: true, + GasAdjustment: 1.2, + GasPrices: "0.0025uosmo", + MinGasAmount: 1, + MaxGasAmount: 0, + Debug: false, + Timeout: "30s", + BlockTimeout: "30s", + OutputFormat: "json", + SignModeStr: "direct", + ExtraCodecs: nil, + Modules: nil, + Slip44: &coinType, + SigningAlgorithm: "", + Broadcast: "batch", + MinLoopDuration: 0, + ExtensionOptions: nil, + FeeGrants: nil, + } +) + +func TestQueryBaseFee(t *testing.T) { + p, err := testCfg.NewProvider(nil, t.TempDir(), true, testCfg.ChainName) + require.NoError(t, err) + + ctx := context.Background() + err = p.Init(ctx) + require.NoError(t, err) + + cp := p.(*CosmosProvider) + + baseFee, err := cp.QueryBaseFee(ctx) + require.NoError(t, err) + require.NotEqual(t, "", baseFee) +} + +func TestParseDenom(t *testing.T) { + denom, err := parseTokenDenom(testCfg.GasPrices) + require.NoError(t, err) + require.Equal(t, "uosmo", denom) +} diff --git a/relayer/chains/cosmos/feegrant.go b/relayer/chains/cosmos/feegrant.go index e2ffbab45..0d1ef1f4e 100644 --- a/relayer/chains/cosmos/feegrant.go +++ b/relayer/chains/cosmos/feegrant.go @@ -4,16 +4,17 @@ import ( "context" "errors" "fmt" - "regexp" "strconv" "time" + sdkmath "cosmossdk.io/math" + "cosmossdk.io/x/feegrant" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/crypto/hd" "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types" txtypes "github.com/cosmos/cosmos-sdk/types/tx" - "github.com/cosmos/cosmos-sdk/x/feegrant" + "go.uber.org/zap" ) // Searches for valid, existing BasicAllowance grants for the ChainClient's configured Feegranter. @@ -25,7 +26,7 @@ func (cc *CosmosProvider) GetValidBasicGrants() ([]*feegrant.Grant, error) { return nil, errors.New("no feegrant configuration for chainclient") } - keyNameOrAddress := cc.PCfg.FeeGrants.GranterKey + keyNameOrAddress := cc.PCfg.FeeGrants.GranterKeyOrAddr address, err := cc.AccountFromKeyOrAddress(keyNameOrAddress) if err != nil { return nil, err @@ -40,18 +41,19 @@ func (cc *CosmosProvider) GetValidBasicGrants() ([]*feegrant.Grant, error) { for _, grant := range grants { switch grant.Allowance.TypeUrl { case "/cosmos.feegrant.v1beta1.BasicAllowance": - //var feegrantAllowance feegrant.BasicAllowance var feegrantAllowance feegrant.FeeAllowanceI e := cc.Cdc.InterfaceRegistry.UnpackAny(grant.Allowance, &feegrantAllowance) if e != nil { return nil, e } - //feegrantAllowance := grant.Allowance.GetCachedValue().(*feegrant.BasicAllowance) if isValidGrant(feegrantAllowance.(*feegrant.BasicAllowance)) { validGrants = append(validGrants, grant) } default: - fmt.Printf("Ignoring grant type %s for granter %s and grantee %s\n", grant.Allowance.TypeUrl, grant.Granter, grant.Grantee) + cc.log.Debug("Ignoring grant", + zap.String("type", grant.Allowance.TypeUrl), + zap.String("granter", grant.Granter), + zap.String("grantee", grant.Grantee)) } } @@ -67,7 +69,7 @@ func (cc *CosmosProvider) GetGranteeValidBasicGrants(granteeKey string) ([]*feeg return nil, errors.New("no feegrant configuration for chainclient") } - granterAddr, err := cc.AccountFromKeyOrAddress(cc.PCfg.FeeGrants.GranterKey) + granterAddr, err := cc.AccountFromKeyOrAddress(cc.PCfg.FeeGrants.GranterKeyOrAddr) if err != nil { return nil, err } @@ -97,7 +99,10 @@ func (cc *CosmosProvider) GetGranteeValidBasicGrants(granteeKey string) ([]*feeg validGrants = append(validGrants, grant) } default: - fmt.Printf("Ignoring grant type %s for granter %s and grantee %s\n", grant.Allowance.TypeUrl, grant.Granter, grant.Grantee) + cc.log.Debug("Ignoring grant", + zap.String("type", grant.Allowance.TypeUrl), + zap.String("granter", grant.Granter), + zap.String("grantee", grant.Grantee)) } } } @@ -119,7 +124,7 @@ func isValidGrant(a *feegrant.BasicAllowance) bool { //spending limit is specified, check if there are funds remaining on every coin if a.SpendLimit != nil { for _, coin := range a.SpendLimit { - if coin.Amount.LTE(types.ZeroInt()) { + if coin.Amount.LTE(sdkmath.ZeroInt()) { valid = false } } @@ -130,9 +135,9 @@ func isValidGrant(a *feegrant.BasicAllowance) bool { func (cc *CosmosProvider) ConfigureFeegrants(numGrantees int, granterKey string) error { cc.PCfg.FeeGrants = &FeeGrantConfiguration{ - GranteesWanted: numGrantees, - GranterKey: granterKey, - ManagedGrantees: []string{}, + GranteesWanted: numGrantees, + GranterKeyOrAddr: granterKey, + ManagedGrantees: []string{}, } return cc.PCfg.FeeGrants.AddGranteeKeys(cc) @@ -144,14 +149,14 @@ func (cc *CosmosProvider) ConfigureWithGrantees(grantees []string, granterKey st } cc.PCfg.FeeGrants = &FeeGrantConfiguration{ - GranteesWanted: len(grantees), - GranterKey: granterKey, - ManagedGrantees: grantees, + GranteesWanted: len(grantees), + GranterKeyOrAddr: granterKey, + ManagedGrantees: grantees, } for _, newGrantee := range grantees { if !cc.KeyExists(newGrantee) { - //Add another key to the chain client for the grantee + // Add another key to the chain client for the grantee _, err := cc.AddKey(newGrantee, sdk.CoinType, string(hd.Secp256k1Type)) if err != nil { return err @@ -162,12 +167,36 @@ func (cc *CosmosProvider) ConfigureWithGrantees(grantees []string, granterKey st return nil } +func (cc *CosmosProvider) ConfigureWithExternalGranter(grantees []string, granterAddr string) error { + if len(grantees) == 0 { + return errors.New("list of grantee names cannot be empty") + } + + cc.PCfg.FeeGrants = &FeeGrantConfiguration{ + GranteesWanted: len(grantees), + GranterKeyOrAddr: granterAddr, + ManagedGrantees: grantees, + IsExternalGranter: true, + } + + for _, grantee := range grantees { + k, err := cc.KeyFromKeyOrAddress(grantee) + if k == "" { + return fmt.Errorf("invalid empty grantee name") + } else if err != nil { + return err + } + } + + return nil +} + func (fg *FeeGrantConfiguration) AddGranteeKeys(cc *CosmosProvider) error { for i := len(fg.ManagedGrantees); i < fg.GranteesWanted; i++ { newGranteeIdx := strconv.Itoa(len(fg.ManagedGrantees) + 1) newGrantee := "grantee" + newGranteeIdx - //Add another key to the chain client for the grantee + // Add another key to the chain client for the grantee _, err := cc.AddKey(newGrantee, sdk.CoinType, string(hd.Secp256k1Type)) if err != nil { return err @@ -181,34 +210,32 @@ func (fg *FeeGrantConfiguration) AddGranteeKeys(cc *CosmosProvider) error { // Get the feegrant params to use for the next TX. If feegrants are not configured for the chain client, the default key will be used for TX signing. // Otherwise, a configured feegrantee will be chosen for TX signing in round-robin fashion. -func (cc *CosmosProvider) GetTxFeeGrant() (txSignerKey string, feeGranterKey string) { - //By default, we should sign TXs with the ChainClient's default key +func (cc *CosmosProvider) GetTxFeeGrant() (txSignerKey string, feeGranterKeyOrAddr string) { + // By default, we should sign TXs with the ChainClient's default key txSignerKey = cc.PCfg.Key if cc.PCfg.FeeGrants == nil { - fmt.Printf("cc.Config.FeeGrants == nil\n") return } // Use the ChainClient's configured Feegranter key for the next TX. - feeGranterKey = cc.PCfg.FeeGrants.GranterKey + feeGranterKeyOrAddr = cc.PCfg.FeeGrants.GranterKeyOrAddr // The ChainClient Feegrant configuration has never been verified on chain. // Don't use Feegrants as it could cause the TX to fail on chain. - if feeGranterKey == "" || cc.PCfg.FeeGrants.BlockHeightVerified <= 0 { - fmt.Printf("cc.Config.FeeGrants.BlockHeightVerified <= 0\n") - feeGranterKey = "" + if feeGranterKeyOrAddr == "" || cc.PCfg.FeeGrants.BlockHeightVerified <= 0 { + feeGranterKeyOrAddr = "" return } - //Pick the next managed grantee in the list as the TX signer + // Pick the next managed grantee in the list as the TX signer lastGranteeIdx := cc.PCfg.FeeGrants.GranteeLastSignerIndex if lastGranteeIdx >= 0 && lastGranteeIdx <= len(cc.PCfg.FeeGrants.ManagedGrantees)-1 { txSignerKey = cc.PCfg.FeeGrants.ManagedGrantees[lastGranteeIdx] cc.PCfg.FeeGrants.GranteeLastSignerIndex = cc.PCfg.FeeGrants.GranteeLastSignerIndex + 1 - //Restart the round robin at 0 if we reached the end of the list of grantees + // Restart the round robin at 0 if we reached the end of the list of grantees if cc.PCfg.FeeGrants.GranteeLastSignerIndex == len(cc.PCfg.FeeGrants.ManagedGrantees) { cc.PCfg.FeeGrants.GranteeLastSignerIndex = 0 } @@ -219,27 +246,40 @@ func (cc *CosmosProvider) GetTxFeeGrant() (txSignerKey string, feeGranterKey str // Ensure all Basic Allowance grants are in place for the given ChainClient. // This will query (RPC) for existing grants and create new grants if they don't exist. -func (cc *CosmosProvider) EnsureBasicGrants(ctx context.Context, memo string) (*sdk.TxResponse, error) { +func (cc *CosmosProvider) EnsureBasicGrants(ctx context.Context, memo string, gas uint64) (*sdk.TxResponse, error) { if cc.PCfg.FeeGrants == nil { - return nil, errors.New("ChainClient must be a FeeGranter to establish grants") + return nil, errors.New("chain client must be a FeeGranter to establish grants") } else if len(cc.PCfg.FeeGrants.ManagedGrantees) == 0 { - return nil, errors.New("ChainClient is a FeeGranter, but is not managing any Grantees") + return nil, errors.New("chain client is a FeeGranter, but is not managing any Grantees") } - granterKey := cc.PCfg.FeeGrants.GranterKey + var granterAddr string + var granterAcc types.AccAddress + var err error + + granterKey := cc.PCfg.FeeGrants.GranterKeyOrAddr if granterKey == "" { granterKey = cc.PCfg.Key } - granterAcc, err := cc.GetKeyAddressForKey(granterKey) - if err != nil { - fmt.Printf("Retrieving key '%s': ChainClient FeeGranter misconfiguration: %s", granterKey, err.Error()) - return nil, err - } + if cc.PCfg.FeeGrants.IsExternalGranter { + _, err := cc.DecodeBech32AccAddr(granterKey) + if err != nil { + return nil, fmt.Errorf("an unknown granter was specified: '%s' is not a valid bech32 address", granterKey) + } - granterAddr, granterAddrErr := cc.EncodeBech32AccAddr(granterAcc) - if granterAddrErr != nil { - return nil, granterAddrErr + granterAddr = granterKey + } else { + granterAcc, err = cc.GetKeyAddressForKey(granterKey) + if err != nil { + cc.log.Error("Unknown key", zap.String("name", granterKey)) + return nil, err + } + + granterAddr, err = cc.EncodeBech32AccAddr(granterAcc) + if err != nil { + return nil, err + } } validGrants, err := cc.GetValidBasicGrants() @@ -250,9 +290,8 @@ func (cc *CosmosProvider) EnsureBasicGrants(ctx context.Context, memo string) (* grantsNeeded := 0 for _, grantee := range cc.PCfg.FeeGrants.ManagedGrantees { - - //Searching for all grants with the given granter failed, so we will search by the grantee. - //Reason this lookup sometimes fails is because the 'Search by granter' request is in SDK v0.46+ + // Searching for all grants with the given granter failed, so we will search by the grantee. + // Reason this lookup sometimes fails is because the 'Search by granter' request is in SDK v0.46+ if failedLookupGrantsByGranter { validGrants, err = cc.GetGranteeValidBasicGrants(grantee) if err != nil { @@ -262,7 +301,7 @@ func (cc *CosmosProvider) EnsureBasicGrants(ctx context.Context, memo string) (* granteeAcc, err := cc.GetKeyAddressForKey(grantee) if err != nil { - fmt.Printf("Misconfiguration for grantee key %s. Error: %s\n", grantee, err.Error()) + cc.log.Error("Unknown grantee", zap.String("key_name", grantee)) return nil, err } @@ -274,19 +313,21 @@ func (cc *CosmosProvider) EnsureBasicGrants(ctx context.Context, memo string) (* hasGrant := false for _, basicGrant := range validGrants { if basicGrant.Grantee == granteeAddr { - fmt.Printf("Valid grant found for granter %s, grantee %s\n", basicGrant.Granter, basicGrant.Grantee) hasGrant = true } } - if !hasGrant { - grantsNeeded += 1 - fmt.Printf("Grant will be created on chain for granter %s and grantee %s\n", granterAddr, granteeAddr) + if !hasGrant && !cc.PCfg.FeeGrants.IsExternalGranter { + grantsNeeded++ + cc.log.Info("Creating feegrant", zap.String("granter", granterAddr), zap.String("grantee", granteeAddr)) + grantMsg, err := cc.getMsgGrantBasicAllowance(granterAcc, granteeAcc) if err != nil { return nil, err } msgs = append(msgs, grantMsg) + } else if !hasGrant { + cc.log.Warn("Missing feegrant", zap.String("external_granter", granterAddr), zap.String("grantee", granteeAddr)) } } @@ -299,37 +340,24 @@ func (cc *CosmosProvider) EnsureBasicGrants(ctx context.Context, memo string) (* granterExists := cc.EnsureExists(cliCtx, granterAcc) == nil - //Feegranter exists on chain + // Feegranter exists on chain if granterExists { - txResp, err := cc.SubmitTxAwaitResponse(ctx, msgs, memo, 0, granterKey) + txResp, err := cc.SubmitTxAwaitResponse(ctx, msgs, memo, gas, granterKey) if err != nil { - fmt.Printf("Error: SubmitTxAwaitResponse: %s", err.Error()) return nil, err } else if txResp != nil && txResp.TxResponse != nil && txResp.TxResponse.Code != 0 { - fmt.Printf("Submitting grants for granter %s failed. Code: %d, TX hash: %s\n", granterKey, txResp.TxResponse.Code, txResp.TxResponse.TxHash) + cc.log.Warn("Feegrant TX failed", zap.String("tx_hash", txResp.TxResponse.TxHash), zap.Uint32("code", txResp.TxResponse.Code)) return nil, fmt.Errorf("could not configure feegrant for granter %s", granterKey) } - fmt.Printf("TX succeeded, %d new grants configured, %d grants already in place. TX hash: %s\n", grantsNeeded, numGrantees-grantsNeeded, txResp.TxResponse.TxHash) + cc.log.Info("Feegrant succeeded", zap.Int("new_grants", grantsNeeded), zap.Int("existing_grants", numGrantees-grantsNeeded), zap.String("tx_hash", txResp.TxResponse.TxHash)) return txResp.TxResponse, err - } else { - return nil, fmt.Errorf("granter %s does not exist on chain", granterKey) } - } else { - fmt.Printf("All grantees (%d total) already had valid feegrants. Feegrant configuration verified.\n", numGrantees) - } - return nil, nil -} - -func getGasTokenDenom(gasPrices string) (string, error) { - r := regexp.MustCompile(`(?P[0-9.]*)(?P.*)`) - submatches := r.FindStringSubmatch(gasPrices) - if len(submatches) != 3 { - return "", errors.New("could not find fee denom") + return nil, fmt.Errorf("granter %s does not exist on chain", granterKey) } - return submatches[2], nil + return nil, nil } // GrantBasicAllowance Send a feegrant with the basic allowance type. @@ -337,18 +365,18 @@ func getGasTokenDenom(gasPrices string) (string, error) { // TODO: check for existing authorizations prior to attempting new one. func (cc *CosmosProvider) GrantAllGranteesBasicAllowance(ctx context.Context, gas uint64) error { if cc.PCfg.FeeGrants == nil { - return errors.New("ChainClient must be a FeeGranter to establish grants") + return errors.New("chain client must be a FeeGranter to establish grants") } else if len(cc.PCfg.FeeGrants.ManagedGrantees) == 0 { - return errors.New("ChainClient is a FeeGranter, but is not managing any Grantees") + return errors.New("chain client is a FeeGranter, but is not managing any Grantees") } - granterKey := cc.PCfg.FeeGrants.GranterKey + granterKey := cc.PCfg.FeeGrants.GranterKeyOrAddr if granterKey == "" { granterKey = cc.PCfg.Key } granterAddr, err := cc.GetKeyAddressForKey(granterKey) if err != nil { - fmt.Printf("ChainClient FeeGranter misconfiguration: %s", err.Error()) + cc.log.Error("Unknown granter", zap.String("key_name", granterKey)) return err } @@ -356,7 +384,7 @@ func (cc *CosmosProvider) GrantAllGranteesBasicAllowance(ctx context.Context, ga granteeAddr, err := cc.GetKeyAddressForKey(grantee) if err != nil { - fmt.Printf("Misconfiguration for grantee %s. Error: %s\n", grantee, err.Error()) + cc.log.Error("Unknown grantee", zap.String("key_name", grantee)) return err } @@ -364,7 +392,6 @@ func (cc *CosmosProvider) GrantAllGranteesBasicAllowance(ctx context.Context, ga if err != nil { return err } else if grantResp != nil && grantResp.TxResponse != nil && grantResp.TxResponse.Code != 0 { - fmt.Printf("grantee %s and granter %s. Code: %d\n", granterAddr.String(), granteeAddr.String(), grantResp.TxResponse.Code) return fmt.Errorf("could not configure feegrant for granter %s and grantee %s", granterAddr.String(), granteeAddr.String()) } } @@ -373,22 +400,21 @@ func (cc *CosmosProvider) GrantAllGranteesBasicAllowance(ctx context.Context, ga // GrantBasicAllowance Send a feegrant with the basic allowance type. // This function does not check for existing feegrant authorizations. -// TODO: check for existing authorizations prior to attempting new one. func (cc *CosmosProvider) GrantAllGranteesBasicAllowanceWithExpiration(ctx context.Context, gas uint64, expiration time.Time) error { if cc.PCfg.FeeGrants == nil { - return errors.New("ChainClient must be a FeeGranter to establish grants") + return errors.New("chain client must be a FeeGranter to establish grants") } else if len(cc.PCfg.FeeGrants.ManagedGrantees) == 0 { - return errors.New("ChainClient is a FeeGranter, but is not managing any Grantees") + return errors.New("chain client is a FeeGranter, but is not managing any Grantees") } - granterKey := cc.PCfg.FeeGrants.GranterKey + granterKey := cc.PCfg.FeeGrants.GranterKeyOrAddr if granterKey == "" { granterKey = cc.PCfg.Key } granterAddr, err := cc.GetKeyAddressForKey(granterKey) if err != nil { - fmt.Printf("ChainClient FeeGranter misconfiguration: %s", err.Error()) + cc.log.Error("Unknown granter", zap.String("key_name", granterKey)) return err } @@ -396,7 +422,7 @@ func (cc *CosmosProvider) GrantAllGranteesBasicAllowanceWithExpiration(ctx conte granteeAddr, err := cc.GetKeyAddressForKey(grantee) if err != nil { - fmt.Printf("Misconfiguration for grantee %s. Error: %s\n", grantee, err.Error()) + cc.log.Error("Unknown grantee", zap.String("key_name", grantee)) return err } @@ -404,7 +430,6 @@ func (cc *CosmosProvider) GrantAllGranteesBasicAllowanceWithExpiration(ctx conte if err != nil { return err } else if grantResp != nil && grantResp.TxResponse != nil && grantResp.TxResponse.Code != 0 { - fmt.Printf("grantee %s and granter %s. Code: %d\n", granterAddr.String(), granteeAddr.String(), grantResp.TxResponse.Code) return fmt.Errorf("could not configure feegrant for granter %s and grantee %s", granterAddr.String(), granteeAddr.String()) } } @@ -412,35 +437,30 @@ func (cc *CosmosProvider) GrantAllGranteesBasicAllowanceWithExpiration(ctx conte } func (cc *CosmosProvider) getMsgGrantBasicAllowanceWithExpiration(granter sdk.AccAddress, grantee sdk.AccAddress, expiration time.Time) (sdk.Msg, error) { - //thirtyMin := time.Now().Add(30 * time.Minute) feeGrantBasic := &feegrant.BasicAllowance{ Expiration: &expiration, } msgGrantAllowance, err := feegrant.NewMsgGrantAllowance(feeGrantBasic, granter, grantee) if err != nil { - fmt.Printf("Error: GrantBasicAllowance.NewMsgGrantAllowance: %s", err.Error()) return nil, err } - //Due to the way Lens configures the SDK, addresses will have the 'cosmos' prefix which - //doesn't necessarily match the chain prefix of the ChainClient config. So calling the internal - //'NewMsgGrantAllowance' function will return the *incorrect* 'cosmos' prefixed bech32 address. - - //Update the Grant to ensure the correct chain-specific granter is set + // Update the Grant to ensure the correct chain-specific granter is set granterAddr, granterAddrErr := cc.EncodeBech32AccAddr(granter) if granterAddrErr != nil { - fmt.Printf("EncodeBech32AccAddr: %s", granterAddrErr.Error()) return nil, granterAddrErr } - //Update the Grant to ensure the correct chain-specific grantee is set + // Update the Grant to ensure the correct chain-specific grantee is set granteeAddr, granteeAddrErr := cc.EncodeBech32AccAddr(grantee) if granteeAddrErr != nil { - fmt.Printf("EncodeBech32AccAddr: %s", granteeAddrErr.Error()) return nil, granteeAddrErr } - //override the 'cosmos' prefixed bech32 addresses with the correct chain prefix + // Due to the way Lens configures the SDK, addresses will have the 'cosmos' prefix which + // doesn't necessarily match the chain prefix of the ChainClient config. So calling the internal + // 'NewMsgGrantAllowance' function will return the *incorrect* 'cosmos' prefixed bech32 address. + // override the 'cosmos' prefixed bech32 addresses with the correct chain prefix msgGrantAllowance.Grantee = granteeAddr msgGrantAllowance.Granter = granterAddr @@ -448,35 +468,28 @@ func (cc *CosmosProvider) getMsgGrantBasicAllowanceWithExpiration(granter sdk.Ac } func (cc *CosmosProvider) getMsgGrantBasicAllowance(granter sdk.AccAddress, grantee sdk.AccAddress) (sdk.Msg, error) { - //thirtyMin := time.Now().Add(30 * time.Minute) - feeGrantBasic := &feegrant.BasicAllowance{ - //Expiration: &thirtyMin, - } + feeGrantBasic := &feegrant.BasicAllowance{} msgGrantAllowance, err := feegrant.NewMsgGrantAllowance(feeGrantBasic, granter, grantee) if err != nil { - fmt.Printf("Error: GrantBasicAllowance.NewMsgGrantAllowance: %s", err.Error()) return nil, err } - //Due to the way Lens configures the SDK, addresses will have the 'cosmos' prefix which - //doesn't necessarily match the chain prefix of the ChainClient config. So calling the internal - //'NewMsgGrantAllowance' function will return the *incorrect* 'cosmos' prefixed bech32 address. - - //Update the Grant to ensure the correct chain-specific granter is set + // Update the Grant to ensure the correct chain-specific granter is set granterAddr, granterAddrErr := cc.EncodeBech32AccAddr(granter) if granterAddrErr != nil { - fmt.Printf("EncodeBech32AccAddr: %s", granterAddrErr.Error()) return nil, granterAddrErr } - //Update the Grant to ensure the correct chain-specific grantee is set + // Update the Grant to ensure the correct chain-specific grantee is set granteeAddr, granteeAddrErr := cc.EncodeBech32AccAddr(grantee) if granteeAddrErr != nil { - fmt.Printf("EncodeBech32AccAddr: %s", granteeAddrErr.Error()) return nil, granteeAddrErr } - //override the 'cosmos' prefixed bech32 addresses with the correct chain prefix + // Due to the way Lens configures the SDK, addresses will have the 'cosmos' prefix which + // doesn't necessarily match the chain prefix of the ChainClient config. So calling the internal + // 'NewMsgGrantAllowance' function will return the *incorrect* 'cosmos' prefixed bech32 address. + // override the 'cosmos' prefixed bech32 addresses with the correct chain prefix msgGrantAllowance.Grantee = granteeAddr msgGrantAllowance.Granter = granterAddr @@ -492,7 +505,6 @@ func (cc *CosmosProvider) GrantBasicAllowance(ctx context.Context, granter sdk.A msgs := []sdk.Msg{msgGrantAllowance} txResp, err := cc.SubmitTxAwaitResponse(ctx, msgs, "", gas, granterKeyName) if err != nil { - fmt.Printf("Error: GrantBasicAllowance.SubmitTxAwaitResponse: %s", err.Error()) return nil, err } @@ -508,7 +520,6 @@ func (cc *CosmosProvider) GrantBasicAllowanceWithExpiration(ctx context.Context, msgs := []sdk.Msg{msgGrantAllowance} txResp, err := cc.SubmitTxAwaitResponse(ctx, msgs, "", gas, granterKeyName) if err != nil { - fmt.Printf("Error: GrantBasicAllowance.SubmitTxAwaitResponse: %s", err.Error()) return nil, err } diff --git a/relayer/chains/cosmos/grpc_query.go b/relayer/chains/cosmos/grpc_query.go index 33f274e8d..1582b96ee 100644 --- a/relayer/chains/cosmos/grpc_query.go +++ b/relayer/chains/cosmos/grpc_query.go @@ -8,7 +8,13 @@ import ( "sync" "time" + sdkerrors "cosmossdk.io/errors" abci "github.com/cometbft/cometbft/abci/types" + "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + legacyerrors "github.com/cosmos/cosmos-sdk/types/errors" + grpctypes "github.com/cosmos/cosmos-sdk/types/grpc" + "github.com/cosmos/cosmos-sdk/types/tx" gogogrpc "github.com/cosmos/gogoproto/grpc" "github.com/cosmos/relayer/v2/relayer/provider" "google.golang.org/grpc" @@ -17,12 +23,6 @@ import ( "google.golang.org/grpc/encoding/proto" "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" - - "github.com/cosmos/cosmos-sdk/codec/types" - sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" - grpctypes "github.com/cosmos/cosmos-sdk/types/grpc" - "github.com/cosmos/cosmos-sdk/types/tx" ) var _ gogogrpc.ClientConn = &CosmosProvider{} @@ -37,17 +37,17 @@ func (cc *CosmosProvider) Invoke(ctx context.Context, method string, req, reply // In both cases, we don't allow empty request req (it will panic unexpectedly). if reflect.ValueOf(req).IsNil() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "request cannot be nil") + return sdkerrors.Wrap(legacyerrors.ErrInvalidRequest, "request cannot be nil") } // Case 1. Broadcasting a Tx. if reqProto, ok := req.(*tx.BroadcastTxRequest); ok { if !ok { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxRequest)(nil), req) + return sdkerrors.Wrapf(legacyerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxRequest)(nil), req) } resProto, ok := reply.(*tx.BroadcastTxResponse) if !ok { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxResponse)(nil), req) + return sdkerrors.Wrapf(legacyerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxResponse)(nil), req) } broadcastRes, err := cc.TxServiceBroadcast(ctx, reqProto) @@ -108,7 +108,7 @@ func (cc *CosmosProvider) RunGRPCQuery(ctx context.Context, method string, req i } if height < 0 { return abci.ResponseQuery{}, nil, sdkerrors.Wrapf( - sdkerrors.ErrInvalidRequest, + legacyerrors.ErrInvalidRequest, "client.Context.Invoke: height (%d) from %q must be >= 0", height, grpctypes.GRPCBlockHeightHeader) } @@ -142,6 +142,7 @@ func (cc *CosmosProvider) RunGRPCQuery(ctx context.Context, method string, req i // HeaderCallOption, then we manually set the value of that header to the // metadata. md = metadata.Pairs(grpctypes.GRPCBlockHeightHeader, strconv.FormatInt(abciRes.Height, 10)) + return abciRes, md, nil } @@ -177,7 +178,20 @@ func (cc *CosmosProvider) TxServiceBroadcast(ctx context.Context, req *tx.Broadc wg.Add(1) - if err := cc.broadcastTx(ctx, req.TxBytes, nil, nil, ctx, blockTimeout, []func(*provider.RelayerTxResponse, error){callback}); err != nil { + dynamicFee := cc.DynamicFee(ctx) + + err = cc.broadcastTx( + ctx, + req.TxBytes, + nil, + nil, + ctx, + blockTimeout, + []func(*provider.RelayerTxResponse, error){callback}, + dynamicFee, + ) + + if err != nil { return nil, err } diff --git a/relayer/chains/cosmos/keys.go b/relayer/chains/cosmos/keys.go index ce6c2a2ef..ff4ecdb05 100644 --- a/relayer/chains/cosmos/keys.go +++ b/relayer/chains/cosmos/keys.go @@ -119,11 +119,15 @@ func (cc *CosmosProvider) KeyAddOrRestore(keyName string, coinType uint32, signi } } + done := SetSDKConfigContext(cc.PCfg.AccountPrefix) + info, err := cc.Keybase.NewAccount(keyName, mnemonicStr, "", hd.CreateHDPath(coinType, 0, 0).String(), algo) if err != nil { return nil, err } + done() + acc, err := info.GetAddress() if err != nil { return nil, err @@ -251,6 +255,10 @@ func (cc *CosmosProvider) KeyFromKeyOrAddress(keyOrAddress string) (string, erro if err != nil { return "", err } + + done := SetSDKConfigContext(cc.PCfg.AccountPrefix) + defer done() + kr, err := cc.Keybase.KeyByAddress(acc) if err != nil { return "", err diff --git a/relayer/chains/cosmos/keys_test.go b/relayer/chains/cosmos/keys_test.go index 987931041..210dc38e3 100644 --- a/relayer/chains/cosmos/keys_test.go +++ b/relayer/chains/cosmos/keys_test.go @@ -92,7 +92,7 @@ func TestKeyRestoreSr25519(t *testing.T) { signatureAlgorithm = "sr25519" mnemonic = "three elevator silk family street child flip also leaf inmate call frame shock little legal october vivid enable fetch siege sell burger dolphin green" accountPrefix = "sei" - expectedAddress = "sei1nmlj0guznnt0qyfj4yl6q5g4xuvgly4qw0w026" + expectedAddress = "sei1th80nzvgkzg7reehtyp4xm39xerqg6z77ymcnx" coinType = uint32(118) ) diff --git a/relayer/chains/cosmos/log.go b/relayer/chains/cosmos/log.go index d0472a820..ccf29816d 100644 --- a/relayer/chains/cosmos/log.go +++ b/relayer/chains/cosmos/log.go @@ -4,14 +4,14 @@ import ( "errors" "reflect" - "github.com/cosmos/cosmos-sdk/codec/types" + "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" typestx "github.com/cosmos/cosmos-sdk/types/tx" - feetypes "github.com/cosmos/ibc-go/v7/modules/apps/29-fee/types" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" + feetypes "github.com/cosmos/ibc-go/v8/modules/apps/29-fee/types" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" "go.uber.org/zap/zapcore" @@ -101,12 +101,13 @@ func (cc *CosmosProvider) LogSuccessTx(res *sdk.TxResponse, msgs []provider.Rela fields = append(fields, zap.Int64("gas_used", res.GasUsed)) // Extract fees and fee_payer if present - ir := types.NewInterfaceRegistry() + cdc := codec.NewProtoCodec(cc.Cdc.InterfaceRegistry) + var m sdk.Msg - if err := ir.UnpackAny(res.Tx, &m); err == nil { + if err := cc.Cdc.InterfaceRegistry.UnpackAny(res.Tx, &m); err == nil { if tx, ok := m.(*typestx.Tx); ok { fields = append(fields, zap.Stringer("fees", tx.GetFee())) - if feePayer := getFeePayer(tx); feePayer != "" { + if feePayer := getFeePayer(cc.log, cdc, tx); feePayer != "" { fields = append(fields, zap.String("fee_payer", feePayer)) } } else { @@ -144,7 +145,7 @@ func msgTypesField(msgs []provider.RelayerMessage) zap.Field { // getFeePayer returns the bech32 address of the fee payer of a transaction. // This uses the fee payer field if set, // otherwise falls back to the address of whoever signed the first message. -func getFeePayer(tx *typestx.Tx) string { +func getFeePayer(log *zap.Logger, cdc *codec.ProtoCodec, tx *typestx.Tx) string { payer := tx.AuthInfo.Fee.Payer if payer != "" { return payer @@ -178,6 +179,12 @@ func getFeePayer(tx *typestx.Tx) string { case *feetypes.MsgPayPacketFeeAsync: return firstMsg.PacketFee.RefundAddress default: - return firstMsg.GetSigners()[0].String() + signers, _, err := cdc.GetMsgV1Signers(firstMsg) + if err != nil { + log.Info("Could not get signers for msg when attempting to get the fee payer", zap.Error(err)) + return "" + } + + return string(signers[0]) } } diff --git a/relayer/chains/cosmos/message_handlers.go b/relayer/chains/cosmos/message_handlers.go index 5f9fce7b1..6f7310c5c 100644 --- a/relayer/chains/cosmos/message_handlers.go +++ b/relayer/chains/cosmos/message_handlers.go @@ -4,8 +4,8 @@ import ( "context" "encoding/hex" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/chains" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" diff --git a/relayer/chains/cosmos/message_handlers_test.go b/relayer/chains/cosmos/message_handlers_test.go index 8038b3e5e..8a807ae16 100644 --- a/relayer/chains/cosmos/message_handlers_test.go +++ b/relayer/chains/cosmos/message_handlers_test.go @@ -3,8 +3,8 @@ package cosmos import ( "testing" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" "github.com/stretchr/testify/require" diff --git a/relayer/chains/cosmos/module/app_module.go b/relayer/chains/cosmos/module/app_module.go index 39e6ea36b..bdf18ae35 100644 --- a/relayer/chains/cosmos/module/app_module.go +++ b/relayer/chains/cosmos/module/app_module.go @@ -4,12 +4,12 @@ import ( "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - solomachine "github.com/cosmos/ibc-go/v7/modules/light-clients/06-solomachine" - localhost "github.com/cosmos/ibc-go/v7/modules/light-clients/09-localhost" + solomachine "github.com/cosmos/ibc-go/v8/modules/light-clients/06-solomachine" + localhost "github.com/cosmos/ibc-go/v8/modules/light-clients/09-localhost" "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" - tmlightclient "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" + tmlightclient "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" ) // AppModuleBasic defines the basic application module used by the module. diff --git a/relayer/chains/cosmos/provider.go b/relayer/chains/cosmos/provider.go index 4133f2db4..f34b1125d 100644 --- a/relayer/chains/cosmos/provider.go +++ b/relayer/chains/cosmos/provider.go @@ -11,19 +11,19 @@ import ( provtypes "github.com/cometbft/cometbft/light/provider" prov "github.com/cometbft/cometbft/light/provider/http" - rpcclient "github.com/cometbft/cometbft/rpc/client" rpchttp "github.com/cometbft/cometbft/rpc/client/http" libclient "github.com/cometbft/cometbft/rpc/jsonrpc/client" "github.com/cosmos/cosmos-sdk/crypto/keyring" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" "github.com/cosmos/gogoproto/proto" - commitmenttypes "github.com/cosmos/ibc-go/v7/modules/core/23-commitment/types" + commitmenttypes "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types" + cwrapper "github.com/cosmos/relayer/v2/client" "github.com/cosmos/relayer/v2/relayer/codecs/ethermint" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" + "github.com/strangelove-ventures/cometbft-client/client" "go.uber.org/zap" - "golang.org/x/mod/semver" ) var ( @@ -32,8 +32,6 @@ var ( _ provider.ProviderConfig = &CosmosProviderConfig{} ) -const cometEncodingThreshold = "v0.37.0-alpha" - type CosmosProviderConfig struct { KeyDirectory string `json:"key-directory" yaml:"key-directory"` Key string `json:"key" yaml:"key"` @@ -42,6 +40,7 @@ type CosmosProviderConfig struct { RPCAddr string `json:"rpc-addr" yaml:"rpc-addr"` AccountPrefix string `json:"account-prefix" yaml:"account-prefix"` KeyringBackend string `json:"keyring-backend" yaml:"keyring-backend"` + DynamicGasPrice bool `json:"dynamic-gas-price" yaml:"dynamic-gas-price"` GasAdjustment float64 `json:"gas-adjustment" yaml:"gas-adjustment"` GasPrices string `json:"gas-prices" yaml:"gas-prices"` MinGasAmount uint64 `json:"min-gas-amount" yaml:"min-gas-amount"` @@ -59,7 +58,7 @@ type CosmosProviderConfig struct { MinLoopDuration time.Duration `json:"min-loop-duration" yaml:"min-loop-duration"` ExtensionOptions []provider.ExtensionOption `json:"extension-options" yaml:"extension-options"` - //If FeeGrantConfiguration is set, TXs submitted by the ChainClient will be signed by the FeeGrantees in a round-robin fashion by default. + // If FeeGrantConfiguration is set, TXs submitted by the ChainClient will be signed by the FeeGrantees in a round-robin fashion by default. FeeGrants *FeeGrantConfiguration `json:"feegrants" yaml:"feegrants"` } @@ -67,13 +66,15 @@ type CosmosProviderConfig struct { // Clients can use other signing keys by invoking 'tx.SendMsgsWith' and specifying the signing key. type FeeGrantConfiguration struct { GranteesWanted int `json:"num_grantees" yaml:"num_grantees"` - //Normally this is the default ChainClient key - GranterKey string `json:"granter" yaml:"granter"` - //List of keys (by name) that this FeeGranter manages + // Normally this is the default ChainClient key + GranterKeyOrAddr string `json:"granter" yaml:"granter"` + // Whether we control the granter private key (if not, someone else must authorize our feegrants) + IsExternalGranter bool `json:"external_granter" yaml:"external_granter"` + // List of keys (by name) that this FeeGranter manages ManagedGrantees []string `json:"grantees" yaml:"grantees"` - //Last checked on chain (0 means grants never checked and may not exist) + // Last checked on chain (0 means grants never checked and may not exist) BlockHeightVerified int64 `json:"block_last_verified" yaml:"block_last_verified"` - //Index of the last ManagedGrantee used as a TX signer + // Index of the last ManagedGrantee used as a TX signer GranteeLastSignerIndex int } @@ -112,7 +113,7 @@ func (pc CosmosProviderConfig) NewProvider(log *zap.Logger, homepath string, deb walletStateMap: map[string]*WalletState{}, // TODO: this is a bit of a hack, we should probably have a better way to inject modules - Cdc: MakeCodec(pc.Modules, pc.ExtraCodecs), + Cdc: MakeCodec(pc.Modules, pc.ExtraCodecs, pc.AccountPrefix, pc.AccountPrefix+"valoper"), } return cp, nil @@ -124,7 +125,7 @@ type CosmosProvider struct { PCfg CosmosProviderConfig Keybase keyring.Keyring KeyringOptions []keyring.Option - RPCClient rpcclient.Client + RPCClient cwrapper.RPCClient LightProvider provtypes.Provider Input io.Reader Output io.Writer @@ -147,6 +148,9 @@ type CosmosProvider struct { // for comet < v0.37, decode tm events as base64 cometLegacyEncoding bool + + // for comet < v0.38, use legacy RPC client for ResultsBlockResults + cometLegacyBlockResults bool } type WalletState struct { @@ -225,7 +229,7 @@ func (cc *CosmosProvider) AccountFromKeyOrAddress(keyOrAddress string) (out sdk. return } -func (cc *CosmosProvider) TrustingPeriod(ctx context.Context, overrideUnbondingPeriod time.Duration) (time.Duration, error) { +func (cc *CosmosProvider) TrustingPeriod(ctx context.Context, overrideUnbondingPeriod time.Duration, percentage int64) (time.Duration, error) { unbondingTime := overrideUnbondingPeriod var err error @@ -236,13 +240,13 @@ func (cc *CosmosProvider) TrustingPeriod(ctx context.Context, overrideUnbondingP } } - // We want the trusting period to be 85% of the unbonding time. + // We want the trusting period to be `percentage` of the unbonding time. // Go mentions that the time.Duration type can track approximately 290 years. // We don't want to lose precision if the duration is a very long duration // by converting int64 to float64. // Use integer math the whole time, first reducing by a factor of 100 - // and then re-growing by 85x. - tp := unbondingTime / 100 * 85 + // and then re-growing by the `percentage` param. + tp := time.Duration(int64(unbondingTime) / 100 * percentage) // And we only want the trusting period to be whole hours. // But avoid rounding if the time is less than 1 hour @@ -273,7 +277,14 @@ func (cc *CosmosProvider) SetRpcAddr(rpcAddr string) error { // Once initialization is complete an attempt to query the underlying node's tendermint version is performed. // NOTE: Init must be called after creating a new instance of CosmosProvider. func (cc *CosmosProvider) Init(ctx context.Context) error { - keybase, err := keyring.New(cc.PCfg.ChainID, cc.PCfg.KeyringBackend, cc.PCfg.KeyDirectory, cc.Input, cc.Cdc.Marshaler, cc.KeyringOptions...) + keybase, err := keyring.New( + cc.PCfg.ChainID, + cc.PCfg.KeyringBackend, + cc.PCfg.KeyDirectory, + cc.Input, + cc.Cdc.Marshaler, + cc.KeyringOptions..., + ) if err != nil { return err } @@ -284,7 +295,7 @@ func (cc *CosmosProvider) Init(ctx context.Context) error { return err } - rpcClient, err := NewRPCClient(cc.PCfg.RPCAddr, timeout) + c, err := client.NewClient(cc.PCfg.RPCAddr, timeout) if err != nil { return err } @@ -294,18 +305,12 @@ func (cc *CosmosProvider) Init(ctx context.Context) error { return err } + rpcClient := cwrapper.NewRPCClient(c) + cc.RPCClient = rpcClient cc.LightProvider = lightprovider cc.Keybase = keybase - status, err := cc.QueryStatus(ctx) - if err != nil { - // Operations can occur before the node URL is added to the config, so noop here. - return nil - } - - cc.setCometVersion(cc.log, status.NodeInfo.Version) - return nil } @@ -355,14 +360,6 @@ func (cc *CosmosProvider) updateNextAccountSequence(sequenceGuard *WalletState, } } -func (cc *CosmosProvider) setCometVersion(log *zap.Logger, version string) { - cc.cometLegacyEncoding = cc.legacyEncodedEvents(log, version) -} - -func (cc *CosmosProvider) legacyEncodedEvents(log *zap.Logger, version string) bool { - return semver.Compare("v"+version, cometEncodingThreshold) < 0 -} - // keysDir returns a string representing the path on the local filesystem where the keystore will be initialized. func keysDir(home, chainID string) string { return path.Join(home, "keys", chainID) diff --git a/relayer/chains/cosmos/query.go b/relayer/chains/cosmos/query.go index 665d851aa..48886072f 100644 --- a/relayer/chains/cosmos/query.go +++ b/relayer/chains/cosmos/query.go @@ -11,27 +11,27 @@ import ( "sync" "time" + sdkerrors "cosmossdk.io/errors" + "cosmossdk.io/x/feegrant" + upgradetypes "cosmossdk.io/x/upgrade/types" abci "github.com/cometbft/cometbft/abci/types" coretypes "github.com/cometbft/cometbft/rpc/core/types" tmtypes "github.com/cometbft/cometbft/types" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" grpctypes "github.com/cosmos/cosmos-sdk/types/grpc" querytypes "github.com/cosmos/cosmos-sdk/types/query" bankTypes "github.com/cosmos/cosmos-sdk/x/bank/types" - "github.com/cosmos/cosmos-sdk/x/feegrant" "github.com/cosmos/cosmos-sdk/x/params/types/proposal" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" - upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - commitmenttypes "github.com/cosmos/ibc-go/v7/modules/core/23-commitment/types" - host "github.com/cosmos/ibc-go/v7/modules/core/24-host" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" - tmclient "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + commitmenttypes "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types" + host "github.com/cosmos/ibc-go/v8/modules/core/24-host" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + tmclient "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" "github.com/cosmos/relayer/v2/relayer/chains" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" @@ -44,7 +44,7 @@ const PaginationDelay = 10 * time.Millisecond var _ provider.QueryProvider = &CosmosProvider{} // queryIBCMessages returns an array of IBC messages given a tag -func (cc *CosmosProvider) queryIBCMessages(ctx context.Context, log *zap.Logger, page, limit int, query string, base64Encoded bool) ([]chains.IbcMessage, error) { +func (cc *CosmosProvider) queryIBCMessages(ctx context.Context, log *zap.Logger, page, limit int, query string) ([]chains.IbcMessage, error) { if query == "" { return nil, errors.New("query string must be provided") } @@ -57,10 +57,13 @@ func (cc *CosmosProvider) queryIBCMessages(ctx context.Context, log *zap.Logger, return nil, errors.New("limit must greater than 0") } - var eg errgroup.Group chainID := cc.ChainId() - var ibcMsgs []chains.IbcMessage - var mu sync.Mutex + + var ( + eg errgroup.Group + ibcMsgs []chains.IbcMessage + mu sync.Mutex + ) eg.Go(func() error { res, err := cc.RPCClient.BlockSearch(ctx, query, &page, &limit, "") @@ -80,8 +83,7 @@ func (cc *CosmosProvider) queryIBCMessages(ctx context.Context, log *zap.Logger, mu.Lock() defer mu.Unlock() - ibcMsgs = append(ibcMsgs, chains.IbcMessagesFromEvents(log, block.BeginBlockEvents, chainID, 0, base64Encoded)...) - ibcMsgs = append(ibcMsgs, chains.IbcMessagesFromEvents(log, block.EndBlockEvents, chainID, 0, base64Encoded)...) + ibcMsgs = append(ibcMsgs, chains.IbcMessagesFromEvents(log, block.FinalizeBlockEvents, chainID, 0)...) return nil }) @@ -98,7 +100,7 @@ func (cc *CosmosProvider) queryIBCMessages(ctx context.Context, log *zap.Logger, mu.Lock() defer mu.Unlock() for _, tx := range res.Txs { - ibcMsgs = append(ibcMsgs, chains.IbcMessagesFromEvents(log, tx.TxResult.Events, chainID, 0, base64Encoded)...) + ibcMsgs = append(ibcMsgs, chains.IbcMessagesFromEvents(log, tx.TxResult.Events, chainID, 0)...) } return nil @@ -123,7 +125,7 @@ func (cc *CosmosProvider) QueryTx(ctx context.Context, hashHex string) (*provide return nil, err } - events := parseEventsFromResponseDeliverTx(resp.TxResult) + events := parseEventsFromResponseDeliverTx(resp.TxResult.Events) return &provider.RelayerTxResponse{ Height: resp.Height, @@ -157,7 +159,7 @@ func (cc *CosmosProvider) QueryTxs(ctx context.Context, page, limit int, events // at most, one tx in the response. Because of this we don't want to initialize the slice with an initial size. var txResps []*provider.RelayerTxResponse for _, tx := range res.Txs { - relayerEvents := parseEventsFromResponseDeliverTx(tx.TxResult) + relayerEvents := parseEventsFromResponseDeliverTx(tx.TxResult.Events) txResps = append(txResps, &provider.RelayerTxResponse{ Height: tx.Height, TxHash: string(tx.Hash), @@ -171,20 +173,22 @@ func (cc *CosmosProvider) QueryTxs(ctx context.Context, page, limit int, events // parseEventsFromResponseDeliverTx parses the events from a ResponseDeliverTx and builds a slice // of provider.RelayerEvent's. -func parseEventsFromResponseDeliverTx(resp abci.ResponseDeliverTx) []provider.RelayerEvent { - var events []provider.RelayerEvent +func parseEventsFromResponseDeliverTx(events []abci.Event) []provider.RelayerEvent { + var rlyEvents []provider.RelayerEvent - for _, event := range resp.Events { + for _, event := range events { attributes := make(map[string]string) for _, attribute := range event.Attributes { - attributes[string(attribute.Key)] = string(attribute.Value) + attributes[attribute.Key] = attribute.Value } - events = append(events, provider.RelayerEvent{ + + rlyEvents = append(rlyEvents, provider.RelayerEvent{ EventType: event.Type, Attributes: attributes, }) } - return events + + return rlyEvents } // QueryFeegrantsByGrantee returns all requested grants for the given grantee. @@ -878,22 +882,18 @@ func (cc *CosmosProvider) QueryConnectionChannels(ctx context.Context, height in return channels, nil } -// QueryChannels returns all the channels that are registered on a chain +// QueryChannels returns all the channels that are registered on a chain. func (cc *CosmosProvider) QueryChannels(ctx context.Context) ([]*chantypes.IdentifiedChannel, error) { - qc := chantypes.NewQueryClient(cc) p := DefaultPageRequest() chans := []*chantypes.IdentifiedChannel{} for { - res, err := qc.Channels(ctx, &chantypes.QueryChannelsRequest{ - Pagination: p, - }) + res, next, err := cc.QueryChannelsPaginated(ctx, p) if err != nil { return nil, err } - chans = append(chans, res.Channels...) - next := res.GetPagination().GetNextKey() + chans = append(chans, res...) if len(next) == 0 { break } @@ -901,13 +901,19 @@ func (cc *CosmosProvider) QueryChannels(ctx context.Context) ([]*chantypes.Ident time.Sleep(PaginationDelay) p.Key = next } + return chans, nil } -// QueryChannels returns all the channels that are registered on a chain -func (cc *CosmosProvider) QueryChannelsPaginated(ctx context.Context, pageRequest *querytypes.PageRequest) ([]*chantypes.IdentifiedChannel, []byte, error) { +// QueryChannelsPaginated returns all the channels for a particular paginated request that are registered on a chain. +func (cc *CosmosProvider) QueryChannelsPaginated( + ctx context.Context, + pageRequest *querytypes.PageRequest, +) ([]*chantypes.IdentifiedChannel, []byte, error) { qc := chantypes.NewQueryClient(cc) - chans := []*chantypes.IdentifiedChannel{} + + ctx, cancel := context.WithTimeout(ctx, time.Second*10) + defer cancel() res, err := qc.Channels(ctx, &chantypes.QueryChannelsRequest{ Pagination: pageRequest, @@ -916,10 +922,9 @@ func (cc *CosmosProvider) QueryChannelsPaginated(ctx context.Context, pageReques return nil, nil, err } - chans = append(chans, res.Channels...) next := res.GetPagination().GetNextKey() - return chans, next, nil + return res.Channels, next, nil } // QueryPacketCommitments returns an array of packet commitments @@ -1015,26 +1020,25 @@ func (cc *CosmosProvider) QuerySendPacket( srcPortID string, sequence uint64, ) (provider.PacketInfo, error) { - status, err := cc.QueryStatus(ctx) - if err != nil { - return provider.PacketInfo{}, err - } - q := sendPacketQuery(srcChanID, srcPortID, sequence) - ibcMsgs, err := cc.queryIBCMessages(ctx, cc.log, 1, 1000, q, cc.legacyEncodedEvents(zap.NewNop(), status.NodeInfo.Version)) + + ibcMsgs, err := cc.queryIBCMessages(ctx, cc.log, 1, 1000, q) if err != nil { return provider.PacketInfo{}, err } + for _, msg := range ibcMsgs { if msg.EventType != chantypes.EventTypeSendPacket { continue } + if pi, ok := msg.Info.(*chains.PacketInfo); ok { if pi.SourceChannel == srcChanID && pi.SourcePort == srcPortID && pi.Sequence == sequence { return provider.PacketInfo(*pi), nil } } } + return provider.PacketInfo{}, fmt.Errorf("no ibc messages found for send_packet query: %s", q) } @@ -1044,26 +1048,25 @@ func (cc *CosmosProvider) QueryRecvPacket( dstPortID string, sequence uint64, ) (provider.PacketInfo, error) { - status, err := cc.QueryStatus(ctx) - if err != nil { - return provider.PacketInfo{}, err - } - q := writeAcknowledgementQuery(dstChanID, dstPortID, sequence) - ibcMsgs, err := cc.queryIBCMessages(ctx, cc.log, 1, 1000, q, cc.legacyEncodedEvents(zap.NewNop(), status.NodeInfo.Version)) + + ibcMsgs, err := cc.queryIBCMessages(ctx, cc.log, 1, 1000, q) if err != nil { return provider.PacketInfo{}, err } + for _, msg := range ibcMsgs { if msg.EventType != chantypes.EventTypeWriteAck { continue } + if pi, ok := msg.Info.(*chains.PacketInfo); ok { if pi.DestChannel == dstChanID && pi.DestPort == dstPortID && pi.Sequence == sequence { return provider.PacketInfo(*pi), nil } } } + return provider.PacketInfo{}, fmt.Errorf("no ibc messages found for write_acknowledgement query: %s", q) } diff --git a/relayer/chains/cosmos/relayer_packets.go b/relayer/chains/cosmos/relayer_packets.go index ad7779c6a..438a6c43d 100644 --- a/relayer/chains/cosmos/relayer_packets.go +++ b/relayer/chains/cosmos/relayer_packets.go @@ -3,8 +3,8 @@ package cosmos import ( "fmt" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/provider" ) diff --git a/relayer/chains/cosmos/stride/messages.go b/relayer/chains/cosmos/stride/messages.go index 29bdf5ed7..d423d3e93 100644 --- a/relayer/chains/cosmos/stride/messages.go +++ b/relayer/chains/cosmos/stride/messages.go @@ -1,8 +1,9 @@ package stride import ( + sdkerrors "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + legacyerrors "github.com/cosmos/cosmos-sdk/types/errors" ) // Originally sourced from https://github.com/Stride-Labs/stride/blob/v5.1.1/x/interchainquery/types/msgs.go @@ -29,11 +30,11 @@ func (msg MsgSubmitQueryResponse) ValidateBasic() error { // check from address _, err := sdk.AccAddressFromBech32(msg.FromAddress) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid fromAddress in ICQ response (%s)", err) + return sdkerrors.Wrapf(legacyerrors.ErrInvalidAddress, "invalid fromAddress in ICQ response (%s)", err) } // check chain_id is not empty if msg.ChainId == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "chain_id cannot be empty in ICQ response") + return sdkerrors.Wrap(legacyerrors.ErrInvalidRequest, "chain_id cannot be empty in ICQ response") } return nil diff --git a/relayer/chains/cosmos/tx.go b/relayer/chains/cosmos/tx.go index 163af0515..89d76e033 100644 --- a/relayer/chains/cosmos/tx.go +++ b/relayer/chains/cosmos/tx.go @@ -13,11 +13,14 @@ import ( "sync" "time" + sdkerrors "cosmossdk.io/errors" + sdkmath "cosmossdk.io/math" + "cosmossdk.io/store/rootmulti" "github.com/avast/retry-go/v4" abci "github.com/cometbft/cometbft/abci/types" "github.com/cometbft/cometbft/libs/bytes" "github.com/cometbft/cometbft/light" - rpcclient "github.com/cometbft/cometbft/rpc/client" + client2 "github.com/cometbft/cometbft/rpc/client" coretypes "github.com/cometbft/cometbft/rpc/core/types" tmtypes "github.com/cometbft/cometbft/types" "github.com/cosmos/cosmos-sdk/client" @@ -26,21 +29,20 @@ import ( "github.com/cosmos/cosmos-sdk/crypto/keyring" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" - "github.com/cosmos/cosmos-sdk/store/rootmulti" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + legacyerrors "github.com/cosmos/cosmos-sdk/types/errors" txtypes "github.com/cosmos/cosmos-sdk/types/tx" "github.com/cosmos/cosmos-sdk/types/tx/signing" - feetypes "github.com/cosmos/ibc-go/v7/modules/apps/29-fee/types" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - commitmenttypes "github.com/cosmos/ibc-go/v7/modules/core/23-commitment/types" - host "github.com/cosmos/ibc-go/v7/modules/core/24-host" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" - tmclient "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" - localhost "github.com/cosmos/ibc-go/v7/modules/light-clients/09-localhost" + feetypes "github.com/cosmos/ibc-go/v8/modules/apps/29-fee/types" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + commitmenttypes "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types" + host "github.com/cosmos/ibc-go/v8/modules/core/24-host" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + tmclient "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" + localhost "github.com/cosmos/ibc-go/v8/modules/light-clients/09-localhost" strideicqtypes "github.com/cosmos/relayer/v2/relayer/chains/cosmos/stride" "github.com/cosmos/relayer/v2/relayer/ethermint" "github.com/cosmos/relayer/v2/relayer/provider" @@ -161,7 +163,7 @@ func (cc *CosmosProvider) SendMessagesToMempool( asyncCtx context.Context, asyncCallbacks []func(*provider.RelayerTxResponse, error), ) error { - txSignerKey, feegranterKey, err := cc.buildSignerConfig(msgs) + txSignerKey, feegranterKeyOrAddr, err := cc.buildSignerConfig(msgs) if err != nil { return err } @@ -170,18 +172,41 @@ func (cc *CosmosProvider) SendMessagesToMempool( sequenceGuard.Mu.Lock() defer sequenceGuard.Mu.Unlock() - txBytes, sequence, fees, err := cc.buildMessages(ctx, msgs, memo, 0, txSignerKey, feegranterKey, sequenceGuard) + dynamicFee := cc.DynamicFee(ctx) + + txBytes, sequence, fees, err := cc.buildMessages( + ctx, + msgs, + memo, + 0, + txSignerKey, + feegranterKeyOrAddr, + sequenceGuard, + dynamicFee, + ) + if err != nil { // Account sequence mismatch errors can happen on the simulated transaction also. - if strings.Contains(err.Error(), sdkerrors.ErrWrongSequence.Error()) { + if strings.Contains(err.Error(), legacyerrors.ErrWrongSequence.Error()) { cc.handleAccountSequenceMismatchError(sequenceGuard, err) } return err } - if err := cc.broadcastTx(ctx, txBytes, msgs, fees, asyncCtx, defaultBroadcastWaitTimeout, asyncCallbacks); err != nil { - if strings.Contains(err.Error(), sdkerrors.ErrWrongSequence.Error()) { + err = cc.broadcastTx( + ctx, + txBytes, + msgs, + fees, + asyncCtx, + defaultBroadcastWaitTimeout, + asyncCallbacks, + dynamicFee, + ) + + if err != nil { + if strings.Contains(err.Error(), legacyerrors.ErrWrongSequence.Error()) { cc.handleAccountSequenceMismatchError(sequenceGuard, err) } @@ -198,7 +223,7 @@ func (cc *CosmosProvider) SubmitTxAwaitResponse(ctx context.Context, msgs []sdk. if err != nil { return nil, err } - fmt.Printf("TX result code: %d. Waiting for TX with hash %s\n", resp.Code, resp.Hash) + tx1resp, err := cc.AwaitTx(resp.Hash, 15*time.Second) if err != nil { return nil, err @@ -251,7 +276,9 @@ func (cc *CosmosProvider) SendMsgsWith(ctx context.Context, msgs []sdk.Msg, memo rand.Seed(time.Now().UnixNano()) feegrantKeyAcc, _ := cc.GetKeyAddressForKey(feegranterKey) - txf, err := cc.PrepareFactory(cc.TxFactory(), signingKey) + dynamicFee := cc.DynamicFee(ctx) + + txf, err := cc.PrepareFactory(cc.TxFactory(dynamicFee), signingKey) if err != nil { return nil, err } @@ -269,9 +296,9 @@ func (cc *CosmosProvider) SendMsgsWith(ctx context.Context, msgs []sdk.Msg, memo } } - //Cannot feegrant your own TX + // Cannot feegrant your own TX if signingKey != feegranterKey && feegranterKey != "" { - //Must be set in Factory to affect gas calculation (sim tx) as well as real tx + // Must be set in Factory to affect gas calculation (sim tx) as well as real tx txf = txf.WithFeeGranter(feegrantKeyAcc) } @@ -300,7 +327,7 @@ func (cc *CosmosProvider) SendMsgsWith(ctx context.Context, msgs []sdk.Msg, memo // ensure that we allways call done, even in case of an error or panic //defer done() - if err = tx.Sign(txf, signingKey, txb, false); err != nil { + if err = tx.Sign(ctx, txf, signingKey, txb, false); err != nil { return err } return nil @@ -357,6 +384,7 @@ func (cc *CosmosProvider) broadcastTx( asyncCtx context.Context, // context for async wait for block inclusion after successful tx broadcast asyncTimeout time.Duration, // timeout for waiting for block inclusion asyncCallbacks []func(*provider.RelayerTxResponse, error), // callback for success/fail of the wait for block inclusion + dynamicFee string, ) error { res, err := cc.RPCClient.BroadcastTxSync(ctx, tx) isErr := err != nil @@ -376,7 +404,7 @@ func (cc *CosmosProvider) broadcastTx( if isFailed { err = cc.sdkError(res.Codespace, res.Code) if err == nil { - err = fmt.Errorf("transaction failed to execute") + err = fmt.Errorf("transaction failed to execute: codespace: %s, code: %d, log: %s", res.Codespace, res.Code, res.Log) } } cc.LogFailedTx(rlyResp, err, msgs) @@ -384,12 +412,10 @@ func (cc *CosmosProvider) broadcastTx( } address, err := cc.Address() if err != nil { - cc.log.Error( - "failed to get relayer bech32 wallet addresss", - zap.Error(err), - ) + return fmt.Errorf("failed to get relayer bech32 wallet address: %w", err) + } - cc.UpdateFeesSpent(cc.ChainId(), cc.Key(), address, fees) + cc.UpdateFeesSpent(cc.ChainId(), cc.Key(), address, fees, dynamicFee) // TODO: maybe we need to check if the node has tx indexing enabled? // if not, we need to find a new way to block until inclusion in a block @@ -437,7 +463,7 @@ func (cc *CosmosProvider) waitForTx( // Check for any registered SDK errors err := cc.sdkError(res.Codespace, res.Code) if err == nil { - err = fmt.Errorf("transaction failed to execute") + err = fmt.Errorf("transaction failed to execute: codespace: %s, code: %d, log: %s", res.Codespace, res.Code, res.RawLog) } if len(callbacks) > 0 { for _, cb := range callbacks { @@ -490,10 +516,12 @@ func (cc *CosmosProvider) mkTxResult(resTx *coretypes.ResultTx) (*sdk.TxResponse if err != nil { return nil, err } + p, ok := txbz.(intoAny) if !ok { return nil, fmt.Errorf("expecting a type implementing intoAny, got: %T", txbz) } + any := p.AsAny() return sdk.NewResponseResultTx(resTx, any, ""), nil } @@ -538,14 +566,14 @@ func parseEventsFromTxResponse(resp *sdk.TxResponse) []provider.RelayerEvent { func (cc *CosmosProvider) buildSignerConfig(msgs []provider.RelayerMessage) ( txSignerKey string, - feegranterKey string, + feegranterKeyOrAddr string, err error, ) { - //Guard against race conditions when choosing a signer/feegranter + // Guard against race conditions when choosing a signer/feegranter cc.feegrantMu.Lock() defer cc.feegrantMu.Unlock() - //Some messages have feegranting disabled. If any message in the TX disables feegrants, then the TX will not be feegranted. + // Some messages have feegranting disabled. If any message in the TX disables feegrants, then the TX will not be feegranted. isFeegrantEligible := cc.PCfg.FeeGrants != nil for _, curr := range msgs { @@ -556,11 +584,11 @@ func (cc *CosmosProvider) buildSignerConfig(msgs []provider.RelayerMessage) ( } } - //By default, we should sign TXs with the provider's default key + // By default, we should sign TXs with the provider's default key txSignerKey = cc.PCfg.Key if isFeegrantEligible { - txSignerKey, feegranterKey = cc.GetTxFeeGrant() + txSignerKey, feegranterKeyOrAddr = cc.GetTxFeeGrant() signerAcc, addrErr := cc.GetKeyAddressForKey(txSignerKey) if addrErr != nil { err = addrErr @@ -573,7 +601,7 @@ func (cc *CosmosProvider) buildSignerConfig(msgs []provider.RelayerMessage) ( return } - //Overwrite the 'Signer' field in any Msgs that provide an 'optionalSetSigner' callback + // Overwrite the 'Signer' field in any Msgs that provide an 'optionalSetSigner' callback for _, curr := range msgs { if cMsg, ok := curr.(CosmosMessage); ok { if cMsg.SetSigner != nil { @@ -592,8 +620,9 @@ func (cc *CosmosProvider) buildMessages( memo string, gas uint64, txSignerKey string, - feegranterKey string, + feegranterKeyOrAddr string, sequenceGuard *WalletState, + dynamicFee string, ) ( txBytes []byte, sequence uint64, @@ -605,7 +634,7 @@ func (cc *CosmosProvider) buildMessages( cMsgs := CosmosMsgs(msgs...) - txf, err := cc.PrepareFactory(cc.TxFactory(), txSignerKey) + txf, err := cc.PrepareFactory(cc.TxFactory(dynamicFee), txSignerKey) if err != nil { return nil, 0, sdk.Coins{}, err } @@ -621,6 +650,24 @@ func (cc *CosmosProvider) buildMessages( txf = txf.WithSequence(sequence) } + // Cannot feegrant your own TX + if txSignerKey != feegranterKeyOrAddr && feegranterKeyOrAddr != "" { + var granterAddr sdk.AccAddress + if cc.PCfg.FeeGrants != nil && cc.PCfg.FeeGrants.IsExternalGranter { + granterAddr, err = cc.DecodeBech32AccAddr(feegranterKeyOrAddr) + if err != nil { + return nil, 0, sdk.Coins{}, err + } + } else { + granterAddr, err = cc.GetKeyAddressForKey(feegranterKeyOrAddr) + if err != nil { + return nil, 0, sdk.Coins{}, err + } + } + + txf = txf.WithFeeGranter(granterAddr) + } + adjusted := gas if gas == 0 { @@ -631,16 +678,6 @@ func (cc *CosmosProvider) buildMessages( } } - //Cannot feegrant your own TX - if txSignerKey != feegranterKey && feegranterKey != "" { - granterAddr, err := cc.GetKeyAddressForKey(feegranterKey) - if err != nil { - return nil, 0, sdk.Coins{}, err - } - - txf = txf.WithFeeGranter(granterAddr) - } - // Set the gas amount on the transaction factory txf = txf.WithGas(adjusted) @@ -650,7 +687,7 @@ func (cc *CosmosProvider) buildMessages( return nil, 0, sdk.Coins{}, err } - if err = tx.Sign(txf, txSignerKey, txb, false); err != nil { + if err = tx.Sign(ctx, txf, txSignerKey, txb, false); err != nil { return nil, 0, sdk.Coins{}, err } @@ -1027,7 +1064,7 @@ func (cc *CosmosProvider) MsgConnectionOpenTry(msgOpenInit provider.ConnectionIn counterparty := conntypes.Counterparty{ ClientId: msgOpenInit.ClientID, ConnectionId: msgOpenInit.ConnID, - Prefix: defaultChainPrefix, + Prefix: msgOpenInit.CounterpartyCommitmentPrefix, } msg := &conntypes.MsgConnectionOpenTry{ @@ -1036,7 +1073,7 @@ func (cc *CosmosProvider) MsgConnectionOpenTry(msgOpenInit provider.ConnectionIn ClientState: csAny, Counterparty: counterparty, DelayPeriod: defaultDelayPeriod, - CounterpartyVersions: conntypes.ExportedVersionsToProto(conntypes.GetCompatibleVersions()), + CounterpartyVersions: conntypes.GetCompatibleVersions(), ProofHeight: proof.ProofHeight, ProofInit: proof.ConnectionStateProof, ProofClient: proof.ClientStateProof, @@ -1305,6 +1342,7 @@ func (cc *CosmosProvider) QueryICQWithProof(ctx context.Context, path string, re if err != nil { return provider.ICQProof{}, fmt.Errorf("failed to execute interchain query: %w", err) } + return provider.ICQProof{ Result: res.Value, ProofOps: res.ProofOps, @@ -1557,7 +1595,8 @@ func (cc *CosmosProvider) NewClientState( dstChainID string, dstUpdateHeader provider.IBCHeader, dstTrustingPeriod, - dstUbdPeriod time.Duration, + dstUbdPeriod, + maxClockDrift time.Duration, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour bool, ) (ibcexported.ClientState, error) { @@ -1569,7 +1608,7 @@ func (cc *CosmosProvider) NewClientState( TrustLevel: tmclient.NewFractionFromTm(light.DefaultTrustLevel), TrustingPeriod: dstTrustingPeriod, UnbondingPeriod: dstUbdPeriod, - MaxClockDrift: time.Minute * 10, + MaxClockDrift: maxClockDrift, FrozenHeight: clienttypes.ZeroHeight(), LatestHeight: clienttypes.Height{ RevisionNumber: revisionNumber, @@ -1582,7 +1621,7 @@ func (cc *CosmosProvider) NewClientState( }, nil } -func (cc *CosmosProvider) UpdateFeesSpent(chain, key, address string, fees sdk.Coins) { +func (cc *CosmosProvider) UpdateFeesSpent(chain, key, address string, fees sdk.Coins, dynamicFee string) { // Don't set the metrics in testing if cc.metrics == nil { return @@ -1592,10 +1631,15 @@ func (cc *CosmosProvider) UpdateFeesSpent(chain, key, address string, fees sdk.C cc.TotalFees = cc.TotalFees.Add(fees...) cc.totalFeesMu.Unlock() + gasPrice := cc.PCfg.GasPrices + if dynamicFee != "" { + gasPrice = dynamicFee + } + for _, fee := range cc.TotalFees { // Convert to a big float to get a float64 for metrics f, _ := big.NewFloat(0.0).SetInt(fee.Amount.BigInt()).Float64() - cc.metrics.SetFeesSpent(chain, cc.PCfg.GasPrices, key, address, fee.GetDenom(), f) + cc.metrics.SetFeesSpent(chain, gasPrice, key, address, fee.GetDenom(), f) } } @@ -1703,7 +1747,7 @@ func (cc *CosmosProvider) AdjustEstimatedGas(gasUsed uint64) (uint64, error) { func (cc *CosmosProvider) SetWithExtensionOptions(txf tx.Factory) (tx.Factory, error) { extOpts := make([]*types.Any, 0, len(cc.PCfg.ExtensionOptions)) for _, opt := range cc.PCfg.ExtensionOptions { - max, ok := sdk.NewIntFromString(opt.Value) + max, ok := sdkmath.NewIntFromString(opt.Value) if !ok { return txf, fmt.Errorf("invalid opt value") } @@ -1762,18 +1806,25 @@ func (cc *CosmosProvider) CalculateGas(ctx context.Context, txf tx.Factory, sign if err := simRes.Unmarshal(res.Value); err != nil { return txtypes.SimulateResponse{}, 0, err } + gas, err := cc.AdjustEstimatedGas(simRes.GasInfo.GasUsed) return simRes, gas, err } // TxFactory instantiates a new tx factory with the appropriate configuration settings for this chain. -func (cc *CosmosProvider) TxFactory() tx.Factory { +func (cc *CosmosProvider) TxFactory(dynamicFee string) tx.Factory { + gasPrice := cc.PCfg.GasPrices + + if dynamicFee != "" { + gasPrice = dynamicFee + } + return tx.Factory{}. WithAccountRetriever(cc). WithChainID(cc.PCfg.ChainID). WithTxConfig(cc.Cdc.TxConfig). WithGasAdjustment(cc.PCfg.GasAdjustment). - WithGasPrices(cc.PCfg.GasPrices). + WithGasPrices(gasPrice). WithKeybase(cc.Keybase). WithSignMode(cc.PCfg.SignMode()) } @@ -1792,10 +1843,11 @@ func (pc *CosmosProviderConfig) SignMode() signing.SignMode { // QueryABCI performs an ABCI query and returns the appropriate response and error sdk error code. func (cc *CosmosProvider) QueryABCI(ctx context.Context, req abci.RequestQuery) (abci.ResponseQuery, error) { - opts := rpcclient.ABCIQueryOptions{ + opts := client2.ABCIQueryOptions{ Height: req.Height, Prove: req.Prove, } + result, err := cc.RPCClient.ABCIQueryWithOptions(ctx, req.Path, req.Data, opts) if err != nil { return abci.ResponseQuery{}, err @@ -1815,11 +1867,11 @@ func (cc *CosmosProvider) QueryABCI(ctx context.Context, req abci.RequestQuery) func sdkErrorToGRPCError(resp abci.ResponseQuery) error { switch resp.Code { - case sdkerrors.ErrInvalidRequest.ABCICode(): + case legacyerrors.ErrInvalidRequest.ABCICode(): return status.Error(codes.InvalidArgument, resp.Log) - case sdkerrors.ErrUnauthorized.ABCICode(): + case legacyerrors.ErrUnauthorized.ABCICode(): return status.Error(codes.Unauthenticated, resp.Log) - case sdkerrors.ErrKeyNotFound.ABCICode(): + case legacyerrors.ErrKeyNotFound.ABCICode(): return status.Error(codes.NotFound, resp.Log) default: return status.Error(codes.Unknown, resp.Log) diff --git a/relayer/chains/cosmos/tx_test.go b/relayer/chains/cosmos/tx_test.go index cf1b086e4..4e9bdcb11 100644 --- a/relayer/chains/cosmos/tx_test.go +++ b/relayer/chains/cosmos/tx_test.go @@ -5,28 +5,18 @@ import ( "math" "testing" + sdkmath "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/tx" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/codec/testutil" "github.com/cosmos/cosmos-sdk/codec/types" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" + authTx "github.com/cosmos/cosmos-sdk/x/auth/tx" "github.com/cosmos/relayer/v2/relayer/ethermint" "github.com/cosmos/relayer/v2/relayer/provider" "github.com/stretchr/testify/require" ) -type mockAccountSequenceMismatchError struct { - Expected uint64 - Actual uint64 -} - -// func TestHandleAccountSequenceMismatchError(t *testing.T) { -// p := &CosmosProvider{} -// ws := &WalletState{} -// p.handleAccountSequenceMismatchError(ws, mockAccountSequenceMismatchError{Actual: 9, Expected: 10}) -// require.Equal(t, ws.NextAccountSequence, uint64(10)) -// } - func TestCosmosProvider_AdjustEstimatedGas(t *testing.T) { testCases := []struct { name string @@ -95,33 +85,6 @@ func TestCosmosProvider_AdjustEstimatedGas(t *testing.T) { } } -func (err mockAccountSequenceMismatchError) Error() string { - return fmt.Sprintf("account sequence mismatch, expected %d, got %d: incorrect account sequence", err.Expected, err.Actual) -} - -type mockTxConfig struct { - legacytx.StdTxConfig - txBuilder *mockTxBuilder -} - -func (cfg mockTxConfig) NewTxBuilder() client.TxBuilder { - if cfg.txBuilder == nil { - cfg.txBuilder = &mockTxBuilder{ - TxBuilder: cfg.StdTxConfig.NewTxBuilder(), - } - } - return cfg.txBuilder -} - -type mockTxBuilder struct { - client.TxBuilder - extOptions []*types.Any -} - -func (b *mockTxBuilder) SetExtensionOptions(extOpts ...*types.Any) { - b.extOptions = extOpts -} - func TestSetWithExtensionOptions(t *testing.T) { cc := &CosmosProvider{PCfg: CosmosProviderConfig{ ExtensionOptions: []provider.ExtensionOption{ @@ -129,9 +92,11 @@ func TestSetWithExtensionOptions(t *testing.T) { {Value: "2000000000"}, }, }} + + cfg := makeMockTxConfig() txf := tx.Factory{}. WithChainID("chainID"). - WithTxConfig(mockTxConfig{}) + WithTxConfig(cfg) updatedTxf, err := cc.SetWithExtensionOptions(txf) require.NoError(t, err) txb, err := updatedTxf.BuildUnsignedTx() @@ -143,7 +108,7 @@ func TestSetWithExtensionOptions(t *testing.T) { // Check that each extension option was added with the correct type URL and value for i, opt := range cc.PCfg.ExtensionOptions { expectedTypeURL := "/ethermint.types.v1.ExtensionOptionDynamicFeeTx" - max, ok := sdk.NewIntFromString(opt.Value) + max, ok := sdkmath.NewIntFromString(opt.Value) require.True(t, ok) expectedValue, err := (ðermint.ExtensionOptionDynamicFeeTx{ MaxPriorityPrice: max, @@ -155,3 +120,38 @@ func TestSetWithExtensionOptions(t *testing.T) { require.Equal(t, expectedValue, actualValue) } } + +type mockTxConfig struct { + client.TxConfig + txBuilder *mockTxBuilder +} + +func (cfg mockTxConfig) NewTxBuilder() client.TxBuilder { + if cfg.txBuilder == nil { + cfg.txBuilder = &mockTxBuilder{ + TxBuilder: cfg.TxConfig.NewTxBuilder(), + } + } + return cfg.txBuilder +} + +type mockTxBuilder struct { + client.TxBuilder + extOptions []*types.Any +} + +func (b *mockTxBuilder) SetExtensionOptions(extOpts ...*types.Any) { + b.extOptions = extOpts +} + +func makeTxConfig() client.TxConfig { + interfaceRegistry := testutil.CodecOptions{}.NewInterfaceRegistry() + cdc := codec.NewProtoCodec(interfaceRegistry) + return authTx.NewTxConfig(cdc, authTx.DefaultSignModes) +} + +func makeMockTxConfig() mockTxConfig { + return mockTxConfig{ + TxConfig: makeTxConfig(), + } +} diff --git a/relayer/chains/mock/message_handlers.go b/relayer/chains/mock/message_handlers.go index 263f50d71..d59b90ff5 100644 --- a/relayer/chains/mock/message_handlers.go +++ b/relayer/chains/mock/message_handlers.go @@ -3,7 +3,7 @@ package mock import ( "fmt" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" diff --git a/relayer/chains/mock/mock_chain_processor.go b/relayer/chains/mock/mock_chain_processor.go index a0641bd64..f0e4b8173 100644 --- a/relayer/chains/mock/mock_chain_processor.go +++ b/relayer/chains/mock/mock_chain_processor.go @@ -9,7 +9,7 @@ import ( "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "go.uber.org/zap" ) diff --git a/relayer/chains/mock/mock_chain_processor_test.go b/relayer/chains/mock/mock_chain_processor_test.go index 718826917..5b370ac80 100644 --- a/relayer/chains/mock/mock_chain_processor_test.go +++ b/relayer/chains/mock/mock_chain_processor_test.go @@ -7,8 +7,8 @@ import ( "testing" "time" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer" "github.com/cosmos/relayer/v2/relayer/chains/mock" "github.com/cosmos/relayer/v2/relayer/processor" @@ -63,7 +63,7 @@ func TestMockChainAndPathProcessors(t *testing.T) { flushInterval := 6 * time.Hour pathProcessor := processor.NewPathProcessor(log, pathEnd1, pathEnd2, metrics, "", - clientUpdateThresholdTime, flushInterval, relayer.DefaultMaxMsgLength) + clientUpdateThresholdTime, flushInterval, relayer.DefaultMaxMsgLength, 0, 1) eventProcessor := processor.NewEventProcessor(). WithChainProcessors( @@ -96,8 +96,10 @@ func TestMockChainAndPathProcessors(t *testing.T) { // at most 3 msg transfer could still be stuck in queue since chain processor was shut down, so msgrecvpacket would never be "received" by counterparty require.LessOrEqual(t, len(pathEnd1LeftoverMsgTransfer), 3) + // at most 2 msgrecvpacket could still be stuck in the queue require.LessOrEqual(t, len(pathEnd1LeftoverMsgRecvPacket), 2) + // at most 1 msgAcknowledgement could still be stuck in the queue require.LessOrEqual(t, len(pathEnd1LeftoverMsgAcknowledgement), 1) @@ -142,7 +144,9 @@ func getMockMessages(channelKey processor.ChannelKey, mockSequence, mockSequence if int64(*mockSequence)-int64(*mockSequenceCounterparty) > 0 { return []mock.TransactionMessage{} } + *mockSequence++ + mockMessages := []mock.TransactionMessage{ { EventType: chantypes.EventTypeSendPacket, @@ -159,6 +163,7 @@ func getMockMessages(channelKey processor.ChannelKey, mockSequence, mockSequence }, }, } + if *mockSequenceCounterparty > 1 && *lastSentMockMsgRecvCounterparty != *mockSequenceCounterparty { *lastSentMockMsgRecvCounterparty = *mockSequenceCounterparty mockMessages = append(mockMessages, mock.TransactionMessage{ @@ -176,6 +181,7 @@ func getMockMessages(channelKey processor.ChannelKey, mockSequence, mockSequence }, }) } + if *mockSequence > 2 { mockMessages = append(mockMessages, mock.TransactionMessage{ EventType: chantypes.EventTypeAcknowledgePacket, @@ -189,5 +195,6 @@ func getMockMessages(channelKey processor.ChannelKey, mockSequence, mockSequence }, }) } + return mockMessages } diff --git a/relayer/chains/parsing.go b/relayer/chains/parsing.go index 8a267072f..d51944067 100644 --- a/relayer/chains/parsing.go +++ b/relayer/chains/parsing.go @@ -1,7 +1,6 @@ package chains import ( - "encoding/base64" "encoding/hex" "fmt" "strconv" @@ -10,9 +9,9 @@ import ( abci "github.com/cometbft/cometbft/abci/types" sdk "github.com/cosmos/cosmos-sdk/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" @@ -30,43 +29,16 @@ type ibcMessageInfo interface { MarshalLogObject(enc zapcore.ObjectEncoder) error } -func parseBase64Event(log *zap.Logger, event abci.Event) sdk.StringEvent { - evt := sdk.StringEvent{Type: event.Type} - for _, attr := range event.Attributes { - key, err := base64.StdEncoding.DecodeString(attr.Key) - if err != nil { - log.Error("Failed to decode legacy key as base64", zap.String("base64", attr.Key), zap.Error(err)) - continue - } - value, err := base64.StdEncoding.DecodeString(attr.Value) - if err != nil { - log.Error("Failed to decode legacy value as base64", zap.String("base64", attr.Value), zap.Error(err)) - continue - } - evt.Attributes = append(evt.Attributes, sdk.Attribute{ - Key: string(key), - Value: string(value), - }) - } - return evt -} - // IbcMessagesFromEvents parses all events within a transaction to find IBC messages func IbcMessagesFromEvents( log *zap.Logger, events []abci.Event, chainID string, height uint64, - base64Encoded bool, ) (messages []IbcMessage) { for _, event := range events { - var evt sdk.StringEvent - if base64Encoded { - evt = parseBase64Event(log, event) - } else { - evt = sdk.StringifyEvent(event) - } - m := parseIBCMessageFromEvent(log, evt, chainID, height) + evt := sdk.StringifyEvent(event) + m := ParseIBCMessageFromEvent(log, evt, chainID, height) if m == nil || m.Info == nil { // Not an IBC message, don't need to log here continue @@ -81,7 +53,7 @@ type messageInfo interface { ParseAttrs(log *zap.Logger, attrs []sdk.Attribute) } -func parseIBCMessageFromEvent( +func ParseIBCMessageFromEvent( log *zap.Logger, event sdk.StringEvent, chainID string, @@ -90,8 +62,7 @@ func parseIBCMessageFromEvent( var msgInfo messageInfo switch event.Type { case chantypes.EventTypeSendPacket, chantypes.EventTypeRecvPacket, chantypes.EventTypeWriteAck, - chantypes.EventTypeAcknowledgePacket, chantypes.EventTypeTimeoutPacket, - chantypes.EventTypeTimeoutPacketOnClose: + chantypes.EventTypeAcknowledgePacket, chantypes.EventTypeTimeoutPacket: msgInfo = &PacketInfo{Height: height} case chantypes.EventTypeChannelOpenInit, chantypes.EventTypeChannelOpenTry, chantypes.EventTypeChannelOpenAck, chantypes.EventTypeChannelOpenConfirm, @@ -101,8 +72,7 @@ func parseIBCMessageFromEvent( conntypes.EventTypeConnectionOpenAck, conntypes.EventTypeConnectionOpenConfirm: msgInfo = &ConnectionInfo{Height: height} case clienttypes.EventTypeCreateClient, clienttypes.EventTypeUpdateClient, - clienttypes.EventTypeUpgradeClient, clienttypes.EventTypeSubmitMisbehaviour, - clienttypes.EventTypeUpdateClientProposal: + clienttypes.EventTypeUpgradeClient, clienttypes.EventTypeSubmitMisbehaviour: msgInfo = new(ClientInfo) case string(processor.ClientICQTypeRequest), string(processor.ClientICQTypeResponse): msgInfo = &ClientICQInfo{ diff --git a/relayer/chains/penumbra/cnidarium/v1alpha1/cnidarium.pb.go b/relayer/chains/penumbra/cnidarium/v1alpha1/cnidarium.pb.go new file mode 100644 index 000000000..f7ac25a32 --- /dev/null +++ b/relayer/chains/penumbra/cnidarium/v1alpha1/cnidarium.pb.go @@ -0,0 +1,2651 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/cnidarium/v1alpha1/cnidarium.proto + +package cnidariumv1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + types "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +// Performs a key-value query, either by key or by key hash. +// +// Proofs are only supported by key. +type KeyValueRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // If set, the key to fetch from storage. + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + // whether to return a proof + Proof bool `protobuf:"varint,3,opt,name=proof,proto3" json:"proof,omitempty"` +} + +func (m *KeyValueRequest) Reset() { *m = KeyValueRequest{} } +func (m *KeyValueRequest) String() string { return proto.CompactTextString(m) } +func (*KeyValueRequest) ProtoMessage() {} +func (*KeyValueRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_a6006139f070ea05, []int{0} +} +func (m *KeyValueRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyValueRequest.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 *KeyValueRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyValueRequest.Merge(m, src) +} +func (m *KeyValueRequest) XXX_Size() int { + return m.Size() +} +func (m *KeyValueRequest) XXX_DiscardUnknown() { + xxx_messageInfo_KeyValueRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyValueRequest proto.InternalMessageInfo + +func (m *KeyValueRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *KeyValueRequest) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *KeyValueRequest) GetProof() bool { + if m != nil { + return m.Proof + } + return false +} + +type KeyValueResponse struct { + // The value corresponding to the specified key, if it was found. + Value *KeyValueResponse_Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + // A proof of existence or non-existence. + Proof *types.MerkleProof `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` +} + +func (m *KeyValueResponse) Reset() { *m = KeyValueResponse{} } +func (m *KeyValueResponse) String() string { return proto.CompactTextString(m) } +func (*KeyValueResponse) ProtoMessage() {} +func (*KeyValueResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a6006139f070ea05, []int{1} +} +func (m *KeyValueResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyValueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyValueResponse.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 *KeyValueResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyValueResponse.Merge(m, src) +} +func (m *KeyValueResponse) XXX_Size() int { + return m.Size() +} +func (m *KeyValueResponse) XXX_DiscardUnknown() { + xxx_messageInfo_KeyValueResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyValueResponse proto.InternalMessageInfo + +func (m *KeyValueResponse) GetValue() *KeyValueResponse_Value { + if m != nil { + return m.Value + } + return nil +} + +func (m *KeyValueResponse) GetProof() *types.MerkleProof { + if m != nil { + return m.Proof + } + return nil +} + +type KeyValueResponse_Value struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *KeyValueResponse_Value) Reset() { *m = KeyValueResponse_Value{} } +func (m *KeyValueResponse_Value) String() string { return proto.CompactTextString(m) } +func (*KeyValueResponse_Value) ProtoMessage() {} +func (*KeyValueResponse_Value) Descriptor() ([]byte, []int) { + return fileDescriptor_a6006139f070ea05, []int{1, 0} +} +func (m *KeyValueResponse_Value) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyValueResponse_Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyValueResponse_Value.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 *KeyValueResponse_Value) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyValueResponse_Value.Merge(m, src) +} +func (m *KeyValueResponse_Value) XXX_Size() int { + return m.Size() +} +func (m *KeyValueResponse_Value) XXX_DiscardUnknown() { + xxx_messageInfo_KeyValueResponse_Value.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyValueResponse_Value proto.InternalMessageInfo + +func (m *KeyValueResponse_Value) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// Performs a prefixed key-value query, by string prefix. +type PrefixValueRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The prefix to fetch subkeys from storage. + Prefix string `protobuf:"bytes,2,opt,name=prefix,proto3" json:"prefix,omitempty"` +} + +func (m *PrefixValueRequest) Reset() { *m = PrefixValueRequest{} } +func (m *PrefixValueRequest) String() string { return proto.CompactTextString(m) } +func (*PrefixValueRequest) ProtoMessage() {} +func (*PrefixValueRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_a6006139f070ea05, []int{2} +} +func (m *PrefixValueRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PrefixValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PrefixValueRequest.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 *PrefixValueRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PrefixValueRequest.Merge(m, src) +} +func (m *PrefixValueRequest) XXX_Size() int { + return m.Size() +} +func (m *PrefixValueRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PrefixValueRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_PrefixValueRequest proto.InternalMessageInfo + +func (m *PrefixValueRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *PrefixValueRequest) GetPrefix() string { + if m != nil { + return m.Prefix + } + return "" +} + +type PrefixValueResponse struct { + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *PrefixValueResponse) Reset() { *m = PrefixValueResponse{} } +func (m *PrefixValueResponse) String() string { return proto.CompactTextString(m) } +func (*PrefixValueResponse) ProtoMessage() {} +func (*PrefixValueResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a6006139f070ea05, []int{3} +} +func (m *PrefixValueResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PrefixValueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PrefixValueResponse.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 *PrefixValueResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PrefixValueResponse.Merge(m, src) +} +func (m *PrefixValueResponse) XXX_Size() int { + return m.Size() +} +func (m *PrefixValueResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PrefixValueResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_PrefixValueResponse proto.InternalMessageInfo + +func (m *PrefixValueResponse) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *PrefixValueResponse) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// Requests a stream of new key-value pairs that have been committed to the state. +type WatchRequest struct { + // A regex for keys in the verifiable storage. + // + // Only key-value updates whose keys match this regex will be returned. + // Note that the empty string matches all keys. + // To exclude all keys, use the regex "$^", which matches no strings. + KeyRegex string `protobuf:"bytes,1,opt,name=key_regex,json=keyRegex,proto3" json:"key_regex,omitempty"` + // A regex for keys in the nonverifiable storage. + // + // Only key-value updates whose keys match this regex will be returned. + // Note that the empty string matches all keys. + // To exclude all keys, use the regex "$^", which matches no strings. + NvKeyRegex string `protobuf:"bytes,2,opt,name=nv_key_regex,json=nvKeyRegex,proto3" json:"nv_key_regex,omitempty"` +} + +func (m *WatchRequest) Reset() { *m = WatchRequest{} } +func (m *WatchRequest) String() string { return proto.CompactTextString(m) } +func (*WatchRequest) ProtoMessage() {} +func (*WatchRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_a6006139f070ea05, []int{4} +} +func (m *WatchRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WatchRequest.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 *WatchRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_WatchRequest.Merge(m, src) +} +func (m *WatchRequest) XXX_Size() int { + return m.Size() +} +func (m *WatchRequest) XXX_DiscardUnknown() { + xxx_messageInfo_WatchRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_WatchRequest proto.InternalMessageInfo + +func (m *WatchRequest) GetKeyRegex() string { + if m != nil { + return m.KeyRegex + } + return "" +} + +func (m *WatchRequest) GetNvKeyRegex() string { + if m != nil { + return m.NvKeyRegex + } + return "" +} + +// A key-value pair that has been committed to the state. +type WatchResponse struct { + // The state version the key-value pair was committed at. + Version uint64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"` + // The entry that was committed. + // + // Types that are valid to be assigned to Entry: + // *WatchResponse_Kv + // *WatchResponse_NvKv + Entry isWatchResponse_Entry `protobuf_oneof:"entry"` +} + +func (m *WatchResponse) Reset() { *m = WatchResponse{} } +func (m *WatchResponse) String() string { return proto.CompactTextString(m) } +func (*WatchResponse) ProtoMessage() {} +func (*WatchResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a6006139f070ea05, []int{5} +} +func (m *WatchResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WatchResponse.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 *WatchResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_WatchResponse.Merge(m, src) +} +func (m *WatchResponse) XXX_Size() int { + return m.Size() +} +func (m *WatchResponse) XXX_DiscardUnknown() { + xxx_messageInfo_WatchResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_WatchResponse proto.InternalMessageInfo + +type isWatchResponse_Entry interface { + isWatchResponse_Entry() + MarshalTo([]byte) (int, error) + Size() int +} + +type WatchResponse_Kv struct { + Kv *WatchResponse_KeyValue `protobuf:"bytes,5,opt,name=kv,proto3,oneof" json:"kv,omitempty"` +} +type WatchResponse_NvKv struct { + NvKv *WatchResponse_NvKeyValue `protobuf:"bytes,6,opt,name=nv_kv,json=nvKv,proto3,oneof" json:"nv_kv,omitempty"` +} + +func (*WatchResponse_Kv) isWatchResponse_Entry() {} +func (*WatchResponse_NvKv) isWatchResponse_Entry() {} + +func (m *WatchResponse) GetEntry() isWatchResponse_Entry { + if m != nil { + return m.Entry + } + return nil +} + +func (m *WatchResponse) GetVersion() uint64 { + if m != nil { + return m.Version + } + return 0 +} + +func (m *WatchResponse) GetKv() *WatchResponse_KeyValue { + if x, ok := m.GetEntry().(*WatchResponse_Kv); ok { + return x.Kv + } + return nil +} + +func (m *WatchResponse) GetNvKv() *WatchResponse_NvKeyValue { + if x, ok := m.GetEntry().(*WatchResponse_NvKv); ok { + return x.NvKv + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*WatchResponse) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*WatchResponse_Kv)(nil), + (*WatchResponse_NvKv)(nil), + } +} + +// Elements of the verifiable storage have string keys. +type WatchResponse_KeyValue struct { + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + // If set to true, the key-value pair was deleted. + // This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + Deleted bool `protobuf:"varint,3,opt,name=deleted,proto3" json:"deleted,omitempty"` +} + +func (m *WatchResponse_KeyValue) Reset() { *m = WatchResponse_KeyValue{} } +func (m *WatchResponse_KeyValue) String() string { return proto.CompactTextString(m) } +func (*WatchResponse_KeyValue) ProtoMessage() {} +func (*WatchResponse_KeyValue) Descriptor() ([]byte, []int) { + return fileDescriptor_a6006139f070ea05, []int{5, 0} +} +func (m *WatchResponse_KeyValue) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WatchResponse_KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WatchResponse_KeyValue.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 *WatchResponse_KeyValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_WatchResponse_KeyValue.Merge(m, src) +} +func (m *WatchResponse_KeyValue) XXX_Size() int { + return m.Size() +} +func (m *WatchResponse_KeyValue) XXX_DiscardUnknown() { + xxx_messageInfo_WatchResponse_KeyValue.DiscardUnknown(m) +} + +var xxx_messageInfo_WatchResponse_KeyValue proto.InternalMessageInfo + +func (m *WatchResponse_KeyValue) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *WatchResponse_KeyValue) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func (m *WatchResponse_KeyValue) GetDeleted() bool { + if m != nil { + return m.Deleted + } + return false +} + +// Elements of the nonverifiable storage have byte keys. +type WatchResponse_NvKeyValue struct { + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + // If set to true, the key-value pair was deleted. + // This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + Deleted bool `protobuf:"varint,3,opt,name=deleted,proto3" json:"deleted,omitempty"` +} + +func (m *WatchResponse_NvKeyValue) Reset() { *m = WatchResponse_NvKeyValue{} } +func (m *WatchResponse_NvKeyValue) String() string { return proto.CompactTextString(m) } +func (*WatchResponse_NvKeyValue) ProtoMessage() {} +func (*WatchResponse_NvKeyValue) Descriptor() ([]byte, []int) { + return fileDescriptor_a6006139f070ea05, []int{5, 1} +} +func (m *WatchResponse_NvKeyValue) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WatchResponse_NvKeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WatchResponse_NvKeyValue.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 *WatchResponse_NvKeyValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_WatchResponse_NvKeyValue.Merge(m, src) +} +func (m *WatchResponse_NvKeyValue) XXX_Size() int { + return m.Size() +} +func (m *WatchResponse_NvKeyValue) XXX_DiscardUnknown() { + xxx_messageInfo_WatchResponse_NvKeyValue.DiscardUnknown(m) +} + +var xxx_messageInfo_WatchResponse_NvKeyValue proto.InternalMessageInfo + +func (m *WatchResponse_NvKeyValue) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func (m *WatchResponse_NvKeyValue) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func (m *WatchResponse_NvKeyValue) GetDeleted() bool { + if m != nil { + return m.Deleted + } + return false +} + +func init() { + proto.RegisterType((*KeyValueRequest)(nil), "penumbra.cnidarium.v1alpha1.KeyValueRequest") + proto.RegisterType((*KeyValueResponse)(nil), "penumbra.cnidarium.v1alpha1.KeyValueResponse") + proto.RegisterType((*KeyValueResponse_Value)(nil), "penumbra.cnidarium.v1alpha1.KeyValueResponse.Value") + proto.RegisterType((*PrefixValueRequest)(nil), "penumbra.cnidarium.v1alpha1.PrefixValueRequest") + proto.RegisterType((*PrefixValueResponse)(nil), "penumbra.cnidarium.v1alpha1.PrefixValueResponse") + proto.RegisterType((*WatchRequest)(nil), "penumbra.cnidarium.v1alpha1.WatchRequest") + proto.RegisterType((*WatchResponse)(nil), "penumbra.cnidarium.v1alpha1.WatchResponse") + proto.RegisterType((*WatchResponse_KeyValue)(nil), "penumbra.cnidarium.v1alpha1.WatchResponse.KeyValue") + proto.RegisterType((*WatchResponse_NvKeyValue)(nil), "penumbra.cnidarium.v1alpha1.WatchResponse.NvKeyValue") +} + +func init() { + proto.RegisterFile("penumbra/cnidarium/v1alpha1/cnidarium.proto", fileDescriptor_a6006139f070ea05) +} + +var fileDescriptor_a6006139f070ea05 = []byte{ + // 655 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x94, 0xcb, 0x6e, 0xd3, 0x4c, + 0x14, 0xc7, 0x63, 0xb7, 0x6e, 0xd3, 0xd3, 0x7c, 0x1f, 0xd5, 0x80, 0x50, 0x48, 0xd5, 0x50, 0x85, + 0x45, 0xcb, 0xcd, 0x6e, 0x5a, 0xb1, 0x20, 0x88, 0x4d, 0x2a, 0x54, 0xaa, 0x5e, 0x64, 0x02, 0x2a, + 0x17, 0x55, 0x2a, 0x8e, 0x73, 0xda, 0x58, 0x89, 0xed, 0x30, 0x76, 0x46, 0xf5, 0x5b, 0xf0, 0x0c, + 0x2c, 0x59, 0xb2, 0xe1, 0x15, 0x10, 0x12, 0x52, 0x97, 0x2c, 0x51, 0x2a, 0x36, 0x3c, 0x05, 0xf2, + 0x78, 0x26, 0x76, 0x41, 0x8a, 0x5c, 0x76, 0x3e, 0x97, 0xf9, 0x9d, 0xff, 0x9c, 0x73, 0x3c, 0x70, + 0x77, 0x80, 0xde, 0xd0, 0x6d, 0x53, 0xcb, 0xb0, 0x3d, 0xa7, 0x63, 0x51, 0x67, 0xe8, 0x1a, 0xac, + 0x6e, 0xf5, 0x07, 0x5d, 0xab, 0x9e, 0xba, 0xf4, 0x01, 0xf5, 0x43, 0x9f, 0x2c, 0xca, 0x64, 0x3d, + 0x8d, 0xc8, 0xe4, 0xca, 0x8a, 0xd3, 0xb6, 0x0d, 0xdb, 0xa7, 0x68, 0xd8, 0xbe, 0xeb, 0x3a, 0xa1, + 0x8b, 0x5e, 0x68, 0xb0, 0x7a, 0xc6, 0x4a, 0x28, 0xb5, 0x17, 0x70, 0x65, 0x07, 0xa3, 0x03, 0xab, + 0x3f, 0xc4, 0x16, 0xbe, 0x1b, 0x62, 0x10, 0x92, 0x1b, 0x50, 0xb4, 0xbb, 0x96, 0xe3, 0x1d, 0x39, + 0x9d, 0xb2, 0xb2, 0xac, 0xac, 0xce, 0xb5, 0x66, 0xb9, 0xbd, 0xdd, 0x21, 0x0b, 0x30, 0xd5, 0xc3, + 0xa8, 0xac, 0x72, 0x6f, 0xfc, 0x49, 0xae, 0x81, 0x36, 0xa0, 0xbe, 0x7f, 0x5c, 0x9e, 0x5a, 0x56, + 0x56, 0x8b, 0xad, 0xc4, 0xa8, 0x7d, 0x56, 0x60, 0x21, 0xc5, 0x06, 0x03, 0xdf, 0x0b, 0x90, 0x6c, + 0x83, 0xc6, 0x62, 0x07, 0x87, 0xce, 0xaf, 0x6f, 0xe8, 0x13, 0x2e, 0xa0, 0xff, 0x79, 0x5a, 0x4f, + 0xac, 0x84, 0x40, 0x1e, 0xca, 0xaa, 0x2a, 0x47, 0xdd, 0xd2, 0x9d, 0xb6, 0xad, 0xc7, 0xd7, 0xd5, + 0x33, 0x17, 0x64, 0x75, 0x7d, 0x0f, 0x69, 0xaf, 0x8f, 0x66, 0x9c, 0x2a, 0xa4, 0x55, 0x96, 0x40, + 0xe3, 0xa8, 0x58, 0x79, 0x2a, 0xa7, 0x24, 0xc8, 0xb5, 0x2d, 0x20, 0x26, 0xc5, 0x63, 0xe7, 0x34, + 0x6f, 0x4b, 0xae, 0xc3, 0xcc, 0x80, 0x1f, 0x10, 0x5d, 0x11, 0x56, 0xed, 0x31, 0x5c, 0xbd, 0x00, + 0x12, 0x4d, 0x10, 0x1d, 0x54, 0x2e, 0x74, 0x30, 0xd1, 0xa1, 0x66, 0x75, 0xec, 0x41, 0xe9, 0xa5, + 0x15, 0xda, 0x5d, 0xa9, 0x60, 0x11, 0xe6, 0x7a, 0x18, 0x1d, 0x51, 0x3c, 0xc1, 0x53, 0x71, 0xba, + 0xd8, 0xc3, 0xa8, 0x15, 0xdb, 0x64, 0x19, 0x4a, 0x1e, 0x3b, 0x4a, 0xe3, 0x89, 0x12, 0xf0, 0xd8, + 0x8e, 0xc8, 0xa8, 0xfd, 0x54, 0xe1, 0x3f, 0xc1, 0x13, 0x42, 0xca, 0x30, 0xcb, 0x90, 0x06, 0x8e, + 0xef, 0x71, 0xdc, 0x74, 0x4b, 0x9a, 0xe4, 0x09, 0xa8, 0x3d, 0x56, 0xd6, 0x72, 0x0c, 0xe9, 0x02, + 0x71, 0x3c, 0xb2, 0xa7, 0x85, 0x96, 0xda, 0x63, 0x64, 0x17, 0xb4, 0x58, 0x14, 0x2b, 0xcf, 0x70, + 0xd2, 0x83, 0x4b, 0x90, 0xf6, 0x59, 0x86, 0x35, 0xed, 0xb1, 0x1d, 0x56, 0xd9, 0x85, 0xa2, 0xf4, + 0xe5, 0xed, 0x61, 0x7c, 0xc5, 0x0e, 0xf6, 0x31, 0xc4, 0x8e, 0xd8, 0x4e, 0x69, 0x56, 0xf6, 0x01, + 0xd2, 0x1a, 0x59, 0x5e, 0xe9, 0x9f, 0x78, 0xcd, 0x59, 0xd0, 0xd0, 0x0b, 0x69, 0xb4, 0xfe, 0x4d, + 0x85, 0xd2, 0xb3, 0x21, 0xd2, 0xe8, 0x39, 0x52, 0xe6, 0xd8, 0x48, 0x4e, 0x32, 0xba, 0xef, 0xe5, + 0xdc, 0x78, 0x3e, 0xf1, 0xca, 0xfd, 0x4b, 0xfd, 0x1f, 0x84, 0xc2, 0x7c, 0x66, 0xdf, 0x88, 0x31, + 0xf1, 0xf4, 0xdf, 0x2b, 0x5e, 0x59, 0xcb, 0x7f, 0x20, 0xa9, 0xb8, 0xa6, 0x90, 0xb7, 0xa0, 0xf1, + 0xc1, 0x91, 0xdb, 0x79, 0x86, 0x9b, 0xd4, 0xb9, 0x93, 0x7f, 0x0f, 0xd6, 0x94, 0xe6, 0x27, 0xf5, + 0xcb, 0xa8, 0xaa, 0x9c, 0x8d, 0xaa, 0xca, 0x8f, 0x51, 0x55, 0x79, 0x7f, 0x5e, 0x2d, 0x9c, 0x9d, + 0x57, 0x0b, 0xdf, 0xcf, 0xab, 0x05, 0xb8, 0x69, 0xfb, 0xee, 0x24, 0x56, 0xf3, 0xff, 0x4d, 0xe9, + 0x33, 0xe3, 0xa7, 0xce, 0x54, 0xde, 0xbc, 0x3e, 0x71, 0xc2, 0xee, 0xb0, 0x1d, 0x3f, 0x12, 0x86, + 0xed, 0x07, 0xae, 0x1f, 0x18, 0x14, 0xfb, 0x56, 0x84, 0xd4, 0x60, 0xeb, 0xe3, 0x4f, 0xfe, 0x67, + 0x07, 0xc6, 0x84, 0xb7, 0xf8, 0xd1, 0xd8, 0x25, 0x3d, 0x1f, 0xd4, 0x29, 0x73, 0xf3, 0xd5, 0x47, + 0x75, 0xd1, 0x94, 0x82, 0xc6, 0xc5, 0xf5, 0x03, 0x91, 0xf3, 0x35, 0x8d, 0x1e, 0x8e, 0xa3, 0x87, + 0x32, 0x3a, 0x52, 0x57, 0x26, 0x44, 0x0f, 0xb7, 0xcc, 0xe6, 0x1e, 0x86, 0x56, 0xc7, 0x0a, 0xad, + 0x5f, 0xea, 0x92, 0xcc, 0x6c, 0x34, 0xc6, 0xa9, 0x8d, 0x86, 0xcc, 0x6d, 0xcf, 0xf0, 0xa7, 0x7d, + 0xe3, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x11, 0xdf, 0xd8, 0x86, 0x4f, 0x06, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + // General-purpose key-value state query API, that can be used to query + // arbitrary keys in the JMT storage. + KeyValue(ctx context.Context, in *KeyValueRequest, opts ...grpc.CallOption) (*KeyValueResponse, error) + // General-purpose prefixed key-value state query API, that can be used to query + // arbitrary prefixes in the JMT storage. + PrefixValue(ctx context.Context, in *PrefixValueRequest, opts ...grpc.CallOption) (QueryService_PrefixValueClient, error) + // Subscribes to a stream of key-value updates, with regex filtering on keys. + Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (QueryService_WatchClient, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) KeyValue(ctx context.Context, in *KeyValueRequest, opts ...grpc.CallOption) (*KeyValueResponse, error) { + out := new(KeyValueResponse) + err := c.cc.Invoke(ctx, "/penumbra.cnidarium.v1alpha1.QueryService/KeyValue", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) PrefixValue(ctx context.Context, in *PrefixValueRequest, opts ...grpc.CallOption) (QueryService_PrefixValueClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.cnidarium.v1alpha1.QueryService/PrefixValue", opts...) + if err != nil { + return nil, err + } + x := &queryServicePrefixValueClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_PrefixValueClient interface { + Recv() (*PrefixValueResponse, error) + grpc.ClientStream +} + +type queryServicePrefixValueClient struct { + grpc.ClientStream +} + +func (x *queryServicePrefixValueClient) Recv() (*PrefixValueResponse, error) { + m := new(PrefixValueResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *queryServiceClient) Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (QueryService_WatchClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[1], "/penumbra.cnidarium.v1alpha1.QueryService/Watch", opts...) + if err != nil { + return nil, err + } + x := &queryServiceWatchClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_WatchClient interface { + Recv() (*WatchResponse, error) + grpc.ClientStream +} + +type queryServiceWatchClient struct { + grpc.ClientStream +} + +func (x *queryServiceWatchClient) Recv() (*WatchResponse, error) { + m := new(WatchResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + // General-purpose key-value state query API, that can be used to query + // arbitrary keys in the JMT storage. + KeyValue(context.Context, *KeyValueRequest) (*KeyValueResponse, error) + // General-purpose prefixed key-value state query API, that can be used to query + // arbitrary prefixes in the JMT storage. + PrefixValue(*PrefixValueRequest, QueryService_PrefixValueServer) error + // Subscribes to a stream of key-value updates, with regex filtering on keys. + Watch(*WatchRequest, QueryService_WatchServer) error +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) KeyValue(ctx context.Context, req *KeyValueRequest) (*KeyValueResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method KeyValue not implemented") +} +func (*UnimplementedQueryServiceServer) PrefixValue(req *PrefixValueRequest, srv QueryService_PrefixValueServer) error { + return status.Errorf(codes.Unimplemented, "method PrefixValue not implemented") +} +func (*UnimplementedQueryServiceServer) Watch(req *WatchRequest, srv QueryService_WatchServer) error { + return status.Errorf(codes.Unimplemented, "method Watch not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_KeyValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(KeyValueRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).KeyValue(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.cnidarium.v1alpha1.QueryService/KeyValue", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).KeyValue(ctx, req.(*KeyValueRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_PrefixValue_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(PrefixValueRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).PrefixValue(m, &queryServicePrefixValueServer{stream}) +} + +type QueryService_PrefixValueServer interface { + Send(*PrefixValueResponse) error + grpc.ServerStream +} + +type queryServicePrefixValueServer struct { + grpc.ServerStream +} + +func (x *queryServicePrefixValueServer) Send(m *PrefixValueResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_Watch_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).Watch(m, &queryServiceWatchServer{stream}) +} + +type QueryService_WatchServer interface { + Send(*WatchResponse) error + grpc.ServerStream +} + +type queryServiceWatchServer struct { + grpc.ServerStream +} + +func (x *queryServiceWatchServer) Send(m *WatchResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.cnidarium.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "KeyValue", + Handler: _QueryService_KeyValue_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "PrefixValue", + Handler: _QueryService_PrefixValue_Handler, + ServerStreams: true, + }, + { + StreamName: "Watch", + Handler: _QueryService_Watch_Handler, + ServerStreams: true, + }, + }, + Metadata: "penumbra/cnidarium/v1alpha1/cnidarium.proto", +} + +func (m *KeyValueRequest) 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 *KeyValueRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KeyValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Proof { + i-- + if m.Proof { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *KeyValueResponse) 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 *KeyValueResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KeyValueResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Proof != nil { + { + size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCnidarium(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCnidarium(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *KeyValueResponse_Value) 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 *KeyValueResponse_Value) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KeyValueResponse_Value) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PrefixValueRequest) 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 *PrefixValueRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PrefixValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Prefix) > 0 { + i -= len(m.Prefix) + copy(dAtA[i:], m.Prefix) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.Prefix))) + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PrefixValueResponse) 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 *PrefixValueResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PrefixValueResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *WatchRequest) 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 *WatchRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WatchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.NvKeyRegex) > 0 { + i -= len(m.NvKeyRegex) + copy(dAtA[i:], m.NvKeyRegex) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.NvKeyRegex))) + i-- + dAtA[i] = 0x12 + } + if len(m.KeyRegex) > 0 { + i -= len(m.KeyRegex) + copy(dAtA[i:], m.KeyRegex) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.KeyRegex))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *WatchResponse) 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 *WatchResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WatchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Entry != nil { + { + size := m.Entry.Size() + i -= size + if _, err := m.Entry.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + if m.Version != 0 { + i = encodeVarintCnidarium(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *WatchResponse_Kv) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WatchResponse_Kv) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Kv != nil { + { + size, err := m.Kv.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCnidarium(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *WatchResponse_NvKv) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WatchResponse_NvKv) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.NvKv != nil { + { + size, err := m.NvKv.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCnidarium(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + return len(dAtA) - i, nil +} +func (m *WatchResponse_KeyValue) 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 *WatchResponse_KeyValue) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WatchResponse_KeyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Deleted { + i-- + if m.Deleted { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *WatchResponse_NvKeyValue) 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 *WatchResponse_NvKeyValue) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WatchResponse_NvKeyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Deleted { + i-- + if m.Deleted { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintCnidarium(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintCnidarium(dAtA []byte, offset int, v uint64) int { + offset -= sovCnidarium(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *KeyValueRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + if m.Proof { + n += 2 + } + return n +} + +func (m *KeyValueResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovCnidarium(uint64(l)) + } + if m.Proof != nil { + l = m.Proof.Size() + n += 1 + l + sovCnidarium(uint64(l)) + } + return n +} + +func (m *KeyValueResponse_Value) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + return n +} + +func (m *PrefixValueRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + l = len(m.Prefix) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + return n +} + +func (m *PrefixValueResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + return n +} + +func (m *WatchRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.KeyRegex) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + l = len(m.NvKeyRegex) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + return n +} + +func (m *WatchResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Version != 0 { + n += 1 + sovCnidarium(uint64(m.Version)) + } + if m.Entry != nil { + n += m.Entry.Size() + } + return n +} + +func (m *WatchResponse_Kv) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Kv != nil { + l = m.Kv.Size() + n += 1 + l + sovCnidarium(uint64(l)) + } + return n +} +func (m *WatchResponse_NvKv) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NvKv != nil { + l = m.NvKv.Size() + n += 1 + l + sovCnidarium(uint64(l)) + } + return n +} +func (m *WatchResponse_KeyValue) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + if m.Deleted { + n += 2 + } + return n +} + +func (m *WatchResponse_NvKeyValue) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovCnidarium(uint64(l)) + } + if m.Deleted { + n += 2 + } + return n +} + +func sovCnidarium(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozCnidarium(x uint64) (n int) { + return sovCnidarium(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *KeyValueRequest) 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 ErrIntOverflowCnidarium + } + 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: KeyValueRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KeyValueRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + 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 ErrInvalidLengthCnidarium + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + 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 ErrInvalidLengthCnidarium + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Proof = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipCnidarium(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCnidarium + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *KeyValueResponse) 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 ErrIntOverflowCnidarium + } + 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: KeyValueResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KeyValueResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCnidarium + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &KeyValueResponse_Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCnidarium + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proof == nil { + m.Proof = &types.MerkleProof{} + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCnidarium(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCnidarium + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *KeyValueResponse_Value) 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 ErrIntOverflowCnidarium + } + 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: Value: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Value: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCnidarium + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCnidarium(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCnidarium + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrefixValueRequest) 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 ErrIntOverflowCnidarium + } + 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: PrefixValueRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrefixValueRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + 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 ErrInvalidLengthCnidarium + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + 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 ErrInvalidLengthCnidarium + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Prefix = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCnidarium(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCnidarium + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrefixValueResponse) 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 ErrIntOverflowCnidarium + } + 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: PrefixValueResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrefixValueResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + 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 ErrInvalidLengthCnidarium + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCnidarium + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCnidarium(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCnidarium + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WatchRequest) 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 ErrIntOverflowCnidarium + } + 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: WatchRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WatchRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KeyRegex", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + 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 ErrInvalidLengthCnidarium + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.KeyRegex = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NvKeyRegex", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + 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 ErrInvalidLengthCnidarium + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NvKeyRegex = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCnidarium(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCnidarium + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WatchResponse) 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 ErrIntOverflowCnidarium + } + 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: WatchResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WatchResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kv", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCnidarium + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &WatchResponse_KeyValue{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &WatchResponse_Kv{v} + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NvKv", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCnidarium + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &WatchResponse_NvKeyValue{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &WatchResponse_NvKv{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCnidarium(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCnidarium + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WatchResponse_KeyValue) 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 ErrIntOverflowCnidarium + } + 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: KeyValue: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KeyValue: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + 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 ErrInvalidLengthCnidarium + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCnidarium + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Deleted = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipCnidarium(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCnidarium + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WatchResponse_NvKeyValue) 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 ErrIntOverflowCnidarium + } + 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: NvKeyValue: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NvKeyValue: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCnidarium + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCnidarium + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthCnidarium + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCnidarium + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Deleted = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipCnidarium(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCnidarium + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCnidarium(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, ErrIntOverflowCnidarium + } + 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, ErrIntOverflowCnidarium + } + 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, ErrIntOverflowCnidarium + } + 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, ErrInvalidLengthCnidarium + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupCnidarium + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthCnidarium + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthCnidarium = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCnidarium = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupCnidarium = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/codec.go b/relayer/chains/penumbra/codec.go index ac075741c..7ea1c098b 100644 --- a/relayer/chains/penumbra/codec.go +++ b/relayer/chains/penumbra/codec.go @@ -1,6 +1,8 @@ package penumbra import ( + feegrant "cosmossdk.io/x/feegrant/module" + "cosmossdk.io/x/upgrade" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" @@ -12,7 +14,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/bank" "github.com/cosmos/cosmos-sdk/x/crisis" "github.com/cosmos/cosmos-sdk/x/distribution" - feegrant "github.com/cosmos/cosmos-sdk/x/feegrant/module" "github.com/cosmos/cosmos-sdk/x/gov" govclient "github.com/cosmos/cosmos-sdk/x/gov/client" "github.com/cosmos/cosmos-sdk/x/mint" @@ -20,11 +21,9 @@ import ( paramsclient "github.com/cosmos/cosmos-sdk/x/params/client" "github.com/cosmos/cosmos-sdk/x/slashing" "github.com/cosmos/cosmos-sdk/x/staking" - "github.com/cosmos/cosmos-sdk/x/upgrade" - upgradeclient "github.com/cosmos/cosmos-sdk/x/upgrade/client" "github.com/cosmos/ibc-go/modules/capability" - "github.com/cosmos/ibc-go/v7/modules/apps/transfer" - ibc "github.com/cosmos/ibc-go/v7/modules/core" + "github.com/cosmos/ibc-go/v8/modules/apps/transfer" + ibc "github.com/cosmos/ibc-go/v8/modules/core" cosmosmodule "github.com/cosmos/relayer/v2/relayer/chains/cosmos/module" "github.com/cosmos/relayer/v2/relayer/chains/cosmos/stride" @@ -40,8 +39,6 @@ var moduleBasics = []module.AppModuleBasic{ gov.NewAppModuleBasic( []govclient.ProposalHandler{ paramsclient.ProposalHandler, - upgradeclient.LegacyProposalHandler, - upgradeclient.LegacyCancelProposalHandler, }, ), crisis.AppModuleBasic{}, diff --git a/relayer/chains/penumbra/core/app/v1alpha1/app.pb.go b/relayer/chains/penumbra/core/app/v1alpha1/app.pb.go new file mode 100644 index 000000000..16ed64eae --- /dev/null +++ b/relayer/chains/penumbra/core/app/v1alpha1/app.pb.go @@ -0,0 +1,2574 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/app/v1alpha1/app.proto + +package appv1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/chain/v1alpha1" + v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/community_pool/v1alpha1" + v1alpha17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/distributions/v1alpha1" + v1alpha16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1alpha1" + v1alpha13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/governance/v1alpha1" + v1alpha14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1alpha1" + v1alpha18 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1alpha1" + v1alpha15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1alpha1" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +// Requests the list of all transactions that occurred within a given block. +type TransactionsByHeightRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The block height to retrieve. + BlockHeight uint64 `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` +} + +func (m *TransactionsByHeightRequest) Reset() { *m = TransactionsByHeightRequest{} } +func (m *TransactionsByHeightRequest) String() string { return proto.CompactTextString(m) } +func (*TransactionsByHeightRequest) ProtoMessage() {} +func (*TransactionsByHeightRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e3359d6f6803c6c6, []int{0} +} +func (m *TransactionsByHeightRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TransactionsByHeightRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TransactionsByHeightRequest.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 *TransactionsByHeightRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionsByHeightRequest.Merge(m, src) +} +func (m *TransactionsByHeightRequest) XXX_Size() int { + return m.Size() +} +func (m *TransactionsByHeightRequest) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionsByHeightRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionsByHeightRequest proto.InternalMessageInfo + +func (m *TransactionsByHeightRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *TransactionsByHeightRequest) GetBlockHeight() uint64 { + if m != nil { + return m.BlockHeight + } + return 0 +} + +// A transaction that appeared within a given block. +type TransactionsByHeightResponse struct { + // The transactions. + Transactions []*v1alpha1.Transaction `protobuf:"bytes,1,rep,name=transactions,proto3" json:"transactions,omitempty"` + // The block height. + BlockHeight uint64 `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` +} + +func (m *TransactionsByHeightResponse) Reset() { *m = TransactionsByHeightResponse{} } +func (m *TransactionsByHeightResponse) String() string { return proto.CompactTextString(m) } +func (*TransactionsByHeightResponse) ProtoMessage() {} +func (*TransactionsByHeightResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e3359d6f6803c6c6, []int{1} +} +func (m *TransactionsByHeightResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TransactionsByHeightResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TransactionsByHeightResponse.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 *TransactionsByHeightResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionsByHeightResponse.Merge(m, src) +} +func (m *TransactionsByHeightResponse) XXX_Size() int { + return m.Size() +} +func (m *TransactionsByHeightResponse) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionsByHeightResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionsByHeightResponse proto.InternalMessageInfo + +func (m *TransactionsByHeightResponse) GetTransactions() []*v1alpha1.Transaction { + if m != nil { + return m.Transactions + } + return nil +} + +func (m *TransactionsByHeightResponse) GetBlockHeight() uint64 { + if m != nil { + return m.BlockHeight + } + return 0 +} + +type AppParameters struct { + // Chain module parameters. + ChainParams *v1alpha11.ChainParameters `protobuf:"bytes,1,opt,name=chain_params,json=chainParams,proto3" json:"chain_params,omitempty"` + // Community Pool module parameters. + CommunityPoolParams *v1alpha12.CommunityPoolParameters `protobuf:"bytes,2,opt,name=community_pool_params,json=communityPoolParams,proto3" json:"community_pool_params,omitempty"` + // Governance module parameters. + GovernanceParams *v1alpha13.GovernanceParameters `protobuf:"bytes,3,opt,name=governance_params,json=governanceParams,proto3" json:"governance_params,omitempty"` + // IBC module parameters. + IbcParams *v1alpha14.IbcParameters `protobuf:"bytes,4,opt,name=ibc_params,json=ibcParams,proto3" json:"ibc_params,omitempty"` + // Stake module parameters. + StakeParams *v1alpha15.StakeParameters `protobuf:"bytes,5,opt,name=stake_params,json=stakeParams,proto3" json:"stake_params,omitempty"` + // Fee module parameters. + FeeParams *v1alpha16.FeeParameters `protobuf:"bytes,6,opt,name=fee_params,json=feeParams,proto3" json:"fee_params,omitempty"` + // Distributions module parameters. + DistributionsParams *v1alpha17.DistributionsParameters `protobuf:"bytes,7,opt,name=distributions_params,json=distributionsParams,proto3" json:"distributions_params,omitempty"` +} + +func (m *AppParameters) Reset() { *m = AppParameters{} } +func (m *AppParameters) String() string { return proto.CompactTextString(m) } +func (*AppParameters) ProtoMessage() {} +func (*AppParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_e3359d6f6803c6c6, []int{2} +} +func (m *AppParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AppParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AppParameters.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 *AppParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppParameters.Merge(m, src) +} +func (m *AppParameters) XXX_Size() int { + return m.Size() +} +func (m *AppParameters) XXX_DiscardUnknown() { + xxx_messageInfo_AppParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_AppParameters proto.InternalMessageInfo + +func (m *AppParameters) GetChainParams() *v1alpha11.ChainParameters { + if m != nil { + return m.ChainParams + } + return nil +} + +func (m *AppParameters) GetCommunityPoolParams() *v1alpha12.CommunityPoolParameters { + if m != nil { + return m.CommunityPoolParams + } + return nil +} + +func (m *AppParameters) GetGovernanceParams() *v1alpha13.GovernanceParameters { + if m != nil { + return m.GovernanceParams + } + return nil +} + +func (m *AppParameters) GetIbcParams() *v1alpha14.IbcParameters { + if m != nil { + return m.IbcParams + } + return nil +} + +func (m *AppParameters) GetStakeParams() *v1alpha15.StakeParameters { + if m != nil { + return m.StakeParams + } + return nil +} + +func (m *AppParameters) GetFeeParams() *v1alpha16.FeeParameters { + if m != nil { + return m.FeeParams + } + return nil +} + +func (m *AppParameters) GetDistributionsParams() *v1alpha17.DistributionsParameters { + if m != nil { + return m.DistributionsParams + } + return nil +} + +// Requests the global configuration data for the app. +type AppParametersRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` +} + +func (m *AppParametersRequest) Reset() { *m = AppParametersRequest{} } +func (m *AppParametersRequest) String() string { return proto.CompactTextString(m) } +func (*AppParametersRequest) ProtoMessage() {} +func (*AppParametersRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e3359d6f6803c6c6, []int{3} +} +func (m *AppParametersRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AppParametersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AppParametersRequest.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 *AppParametersRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppParametersRequest.Merge(m, src) +} +func (m *AppParametersRequest) XXX_Size() int { + return m.Size() +} +func (m *AppParametersRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AppParametersRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_AppParametersRequest proto.InternalMessageInfo + +func (m *AppParametersRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +type AppParametersResponse struct { + AppParameters *AppParameters `protobuf:"bytes,1,opt,name=app_parameters,json=appParameters,proto3" json:"app_parameters,omitempty"` +} + +func (m *AppParametersResponse) Reset() { *m = AppParametersResponse{} } +func (m *AppParametersResponse) String() string { return proto.CompactTextString(m) } +func (*AppParametersResponse) ProtoMessage() {} +func (*AppParametersResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e3359d6f6803c6c6, []int{4} +} +func (m *AppParametersResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AppParametersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AppParametersResponse.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 *AppParametersResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppParametersResponse.Merge(m, src) +} +func (m *AppParametersResponse) XXX_Size() int { + return m.Size() +} +func (m *AppParametersResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AppParametersResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_AppParametersResponse proto.InternalMessageInfo + +func (m *AppParametersResponse) GetAppParameters() *AppParameters { + if m != nil { + return m.AppParameters + } + return nil +} + +type GenesisAppState struct { + // Types that are valid to be assigned to GenesisAppState: + // *GenesisAppState_GenesisContent + // *GenesisAppState_GenesisCheckpoint + GenesisAppState isGenesisAppState_GenesisAppState `protobuf_oneof:"genesis_app_state"` +} + +func (m *GenesisAppState) Reset() { *m = GenesisAppState{} } +func (m *GenesisAppState) String() string { return proto.CompactTextString(m) } +func (*GenesisAppState) ProtoMessage() {} +func (*GenesisAppState) Descriptor() ([]byte, []int) { + return fileDescriptor_e3359d6f6803c6c6, []int{5} +} +func (m *GenesisAppState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisAppState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisAppState.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 *GenesisAppState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisAppState.Merge(m, src) +} +func (m *GenesisAppState) XXX_Size() int { + return m.Size() +} +func (m *GenesisAppState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisAppState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisAppState proto.InternalMessageInfo + +type isGenesisAppState_GenesisAppState interface { + isGenesisAppState_GenesisAppState() + MarshalTo([]byte) (int, error) + Size() int +} + +type GenesisAppState_GenesisContent struct { + GenesisContent *GenesisContent `protobuf:"bytes,1,opt,name=genesis_content,json=genesisContent,proto3,oneof" json:"genesis_content,omitempty"` +} +type GenesisAppState_GenesisCheckpoint struct { + GenesisCheckpoint []byte `protobuf:"bytes,2,opt,name=genesis_checkpoint,json=genesisCheckpoint,proto3,oneof" json:"genesis_checkpoint,omitempty"` +} + +func (*GenesisAppState_GenesisContent) isGenesisAppState_GenesisAppState() {} +func (*GenesisAppState_GenesisCheckpoint) isGenesisAppState_GenesisAppState() {} + +func (m *GenesisAppState) GetGenesisAppState() isGenesisAppState_GenesisAppState { + if m != nil { + return m.GenesisAppState + } + return nil +} + +func (m *GenesisAppState) GetGenesisContent() *GenesisContent { + if x, ok := m.GetGenesisAppState().(*GenesisAppState_GenesisContent); ok { + return x.GenesisContent + } + return nil +} + +func (m *GenesisAppState) GetGenesisCheckpoint() []byte { + if x, ok := m.GetGenesisAppState().(*GenesisAppState_GenesisCheckpoint); ok { + return x.GenesisCheckpoint + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*GenesisAppState) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*GenesisAppState_GenesisContent)(nil), + (*GenesisAppState_GenesisCheckpoint)(nil), + } +} + +type GenesisContent struct { + // Stake module genesis state. + StakeContent *v1alpha15.GenesisContent `protobuf:"bytes,1,opt,name=stake_content,json=stakeContent,proto3" json:"stake_content,omitempty"` + // Shielded pool module genesis state. + ShieldedPoolContent *v1alpha18.GenesisContent `protobuf:"bytes,2,opt,name=shielded_pool_content,json=shieldedPoolContent,proto3" json:"shielded_pool_content,omitempty"` + // Governance module genesis state. + GovernanceContent *v1alpha13.GenesisContent `protobuf:"bytes,3,opt,name=governance_content,json=governanceContent,proto3" json:"governance_content,omitempty"` + // IBC module genesis state. + IbcContent *v1alpha14.GenesisContent `protobuf:"bytes,4,opt,name=ibc_content,json=ibcContent,proto3" json:"ibc_content,omitempty"` + // Chain module genesis state. + ChainContent *v1alpha11.GenesisContent `protobuf:"bytes,5,opt,name=chain_content,json=chainContent,proto3" json:"chain_content,omitempty"` + // Community Pool module genesis state. + CommunityPoolContent *v1alpha12.GenesisContent `protobuf:"bytes,6,opt,name=community_pool_content,json=communityPoolContent,proto3" json:"community_pool_content,omitempty"` + // Fee module genesis state. + FeeContent *v1alpha16.GenesisContent `protobuf:"bytes,7,opt,name=fee_content,json=feeContent,proto3" json:"fee_content,omitempty"` + // Distributions module genesis state. + DistributionsContent *v1alpha17.GenesisContent `protobuf:"bytes,8,opt,name=distributions_content,json=distributionsContent,proto3" json:"distributions_content,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_e3359d6f6803c6c6, []int{6} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.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 *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetStakeContent() *v1alpha15.GenesisContent { + if m != nil { + return m.StakeContent + } + return nil +} + +func (m *GenesisContent) GetShieldedPoolContent() *v1alpha18.GenesisContent { + if m != nil { + return m.ShieldedPoolContent + } + return nil +} + +func (m *GenesisContent) GetGovernanceContent() *v1alpha13.GenesisContent { + if m != nil { + return m.GovernanceContent + } + return nil +} + +func (m *GenesisContent) GetIbcContent() *v1alpha14.GenesisContent { + if m != nil { + return m.IbcContent + } + return nil +} + +func (m *GenesisContent) GetChainContent() *v1alpha11.GenesisContent { + if m != nil { + return m.ChainContent + } + return nil +} + +func (m *GenesisContent) GetCommunityPoolContent() *v1alpha12.GenesisContent { + if m != nil { + return m.CommunityPoolContent + } + return nil +} + +func (m *GenesisContent) GetFeeContent() *v1alpha16.GenesisContent { + if m != nil { + return m.FeeContent + } + return nil +} + +func (m *GenesisContent) GetDistributionsContent() *v1alpha17.GenesisContent { + if m != nil { + return m.DistributionsContent + } + return nil +} + +func init() { + proto.RegisterType((*TransactionsByHeightRequest)(nil), "penumbra.core.app.v1alpha1.TransactionsByHeightRequest") + proto.RegisterType((*TransactionsByHeightResponse)(nil), "penumbra.core.app.v1alpha1.TransactionsByHeightResponse") + proto.RegisterType((*AppParameters)(nil), "penumbra.core.app.v1alpha1.AppParameters") + proto.RegisterType((*AppParametersRequest)(nil), "penumbra.core.app.v1alpha1.AppParametersRequest") + proto.RegisterType((*AppParametersResponse)(nil), "penumbra.core.app.v1alpha1.AppParametersResponse") + proto.RegisterType((*GenesisAppState)(nil), "penumbra.core.app.v1alpha1.GenesisAppState") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.app.v1alpha1.GenesisContent") +} + +func init() { + proto.RegisterFile("penumbra/core/app/v1alpha1/app.proto", fileDescriptor_e3359d6f6803c6c6) +} + +var fileDescriptor_e3359d6f6803c6c6 = []byte{ + // 1019 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x57, 0x4f, 0x6f, 0xe3, 0x44, + 0x14, 0x8f, 0xd3, 0xed, 0xbf, 0x49, 0xda, 0x65, 0xdd, 0x16, 0x95, 0x00, 0x51, 0x89, 0x10, 0x2a, + 0x1c, 0x6c, 0x9a, 0x5d, 0xb1, 0x28, 0x8b, 0x40, 0x49, 0x57, 0xb4, 0x7b, 0x40, 0x0a, 0x2e, 0xcb, + 0x61, 0xb7, 0x52, 0x34, 0x76, 0x26, 0xc9, 0xd0, 0xc4, 0x33, 0x78, 0x26, 0x95, 0x8a, 0xf8, 0x02, + 0xdc, 0xf6, 0xc4, 0x1d, 0x8e, 0x1c, 0xf8, 0x14, 0x1c, 0x10, 0xa7, 0x3d, 0xc2, 0x0d, 0xb5, 0x37, + 0x3e, 0x05, 0x9a, 0x19, 0x8f, 0x3d, 0xe3, 0x5d, 0x37, 0xed, 0x2d, 0xf3, 0xfe, 0xfc, 0x7e, 0x6f, + 0xfc, 0xde, 0xfb, 0xd9, 0x01, 0xef, 0x53, 0x14, 0xcf, 0x67, 0x61, 0x02, 0xfd, 0x88, 0x24, 0xc8, + 0x87, 0x94, 0xfa, 0xe7, 0x07, 0x70, 0x4a, 0x27, 0xf0, 0x40, 0x1c, 0x3c, 0x9a, 0x10, 0x4e, 0xdc, + 0x86, 0x8e, 0xf2, 0x44, 0x94, 0x27, 0x1c, 0x3a, 0xaa, 0xd1, 0xb6, 0x11, 0x22, 0x32, 0xa3, 0x24, + 0x46, 0x31, 0xf7, 0xa3, 0x09, 0xc4, 0x71, 0x8e, 0x26, 0x8f, 0x0a, 0xaf, 0xf1, 0xb8, 0x34, 0x87, + 0xcc, 0x66, 0xf3, 0x18, 0xf3, 0x8b, 0x01, 0x25, 0x64, 0x6a, 0x24, 0x5b, 0xf6, 0x14, 0xa5, 0x57, + 0x86, 0x32, 0xc4, 0x8c, 0x27, 0x38, 0x9c, 0x73, 0x4c, 0x62, 0x96, 0x83, 0x58, 0xe6, 0x14, 0xc3, + 0x2b, 0xc3, 0x18, 0x21, 0x94, 0x67, 0x8e, 0x10, 0x4a, 0xe3, 0x3f, 0x2b, 0x8b, 0x1f, 0x93, 0x73, + 0x94, 0xc4, 0x30, 0x8e, 0x8c, 0xb4, 0xdc, 0xb6, 0x88, 0x0d, 0x87, 0x51, 0x9e, 0x86, 0xc3, 0x68, + 0xd1, 0x0d, 0xd9, 0x04, 0xa3, 0xe9, 0x10, 0x0d, 0x0b, 0x8f, 0xc9, 0x32, 0xa7, 0x18, 0xa5, 0xfd, + 0x61, 0x1c, 0x9e, 0x19, 0xc5, 0xca, 0x63, 0x9a, 0xf3, 0xc0, 0xce, 0xe1, 0x09, 0x8c, 0x19, 0x8c, + 0xc4, 0x73, 0xcb, 0xe3, 0x0d, 0xa3, 0xca, 0x6a, 0x3d, 0x07, 0x6f, 0x7f, 0x93, 0x1b, 0x59, 0xef, + 0xe2, 0x18, 0xe1, 0xf1, 0x84, 0x07, 0xe8, 0xfb, 0x39, 0x62, 0xdc, 0x7d, 0x0b, 0xac, 0xc9, 0x19, + 0x18, 0xe0, 0xe1, 0xae, 0xb3, 0xe7, 0xec, 0xaf, 0x07, 0xab, 0xf2, 0xfc, 0x64, 0xe8, 0xbe, 0x07, + 0xea, 0xe1, 0x94, 0x44, 0x67, 0x83, 0x89, 0xcc, 0xd8, 0xad, 0xee, 0x39, 0xfb, 0x77, 0x82, 0x9a, + 0xb4, 0x29, 0x90, 0xd6, 0xcf, 0x0e, 0x78, 0xe7, 0xf5, 0xe8, 0x8c, 0x92, 0x98, 0x21, 0xf7, 0x04, + 0xd4, 0x8d, 0x92, 0xd8, 0xae, 0xb3, 0xb7, 0xb4, 0x5f, 0x6b, 0xfb, 0x9e, 0x3d, 0xba, 0x66, 0xd5, + 0xfa, 0x2a, 0x9e, 0x81, 0x1b, 0x58, 0x20, 0x37, 0x29, 0xec, 0x9f, 0x65, 0xb0, 0xd1, 0xa5, 0xb4, + 0x0f, 0x13, 0x38, 0x43, 0x1c, 0x25, 0xcc, 0x7d, 0x06, 0xea, 0xea, 0xa2, 0x54, 0xd8, 0x98, 0xbc, + 0x6c, 0xad, 0xfd, 0xb0, 0x50, 0x49, 0xd6, 0x08, 0x4f, 0x6d, 0x46, 0x56, 0xcd, 0xa1, 0x38, 0xe6, + 0x70, 0x41, 0x2d, 0xca, 0x0c, 0xcc, 0xfd, 0x11, 0xec, 0xd8, 0xbb, 0xa0, 0x49, 0xaa, 0x92, 0xe4, + 0xb8, 0x9c, 0xc4, 0xde, 0xa0, 0x9c, 0x4d, 0xdb, 0xfb, 0x84, 0x4c, 0x0d, 0xd6, 0xad, 0xe8, 0x15, + 0x07, 0x73, 0x63, 0x70, 0x2f, 0x9f, 0x69, 0xcd, 0xbc, 0x24, 0x99, 0xbb, 0xa5, 0xcc, 0xc6, 0x16, + 0x64, 0xac, 0x47, 0x99, 0xcd, 0xa0, 0x7c, 0x63, 0x6c, 0x5b, 0x99, 0x1b, 0x00, 0x80, 0xc3, 0x48, + 0x13, 0xdd, 0x91, 0x44, 0xf7, 0x4b, 0x89, 0xc4, 0xde, 0x64, 0x0c, 0x4f, 0xc2, 0xc8, 0x80, 0x5e, + 0xc7, 0xe9, 0x51, 0x76, 0x47, 0x8e, 0xba, 0x46, 0x5d, 0x5e, 0xd0, 0x1d, 0xb5, 0x17, 0x19, 0xee, + 0x89, 0x38, 0x9a, 0xdd, 0x61, 0x99, 0x41, 0xd6, 0x3b, 0x42, 0x19, 0xf2, 0xca, 0x82, 0x7a, 0x85, + 0xaa, 0x64, 0xb8, 0x5f, 0x22, 0x13, 0x75, 0x7d, 0x84, 0x34, 0xe6, 0x0f, 0x60, 0xdb, 0x12, 0x2e, + 0x8d, 0xbe, 0x2a, 0xd1, 0x8f, 0x4a, 0xd1, 0x6d, 0xb5, 0xcb, 0x78, 0x1e, 0x9b, 0x66, 0xb3, 0xdf, + 0xc3, 0x57, 0x1c, 0xac, 0x75, 0x00, 0xb6, 0xad, 0xd1, 0x5e, 0xbc, 0xca, 0x2d, 0x0c, 0x76, 0x0a, + 0x29, 0xe9, 0x7e, 0xf6, 0xc1, 0x26, 0xa4, 0x54, 0x55, 0x2f, 0x3d, 0xe9, 0x5e, 0x7c, 0xe8, 0x95, + 0xbf, 0x5c, 0x3c, 0x1b, 0x6a, 0x03, 0x9a, 0xc7, 0xd6, 0xef, 0x0e, 0xb8, 0x7b, 0x84, 0x62, 0xc4, + 0x30, 0xeb, 0x52, 0x7a, 0xc2, 0x21, 0x47, 0xee, 0x53, 0x70, 0x77, 0xac, 0x4c, 0x83, 0x88, 0xc4, + 0x1c, 0xc5, 0x3c, 0xa5, 0xf9, 0xe8, 0x3a, 0x9a, 0x14, 0xe5, 0x50, 0x65, 0x1c, 0x57, 0x82, 0xcd, + 0xb1, 0x65, 0x71, 0x7d, 0xe0, 0x66, 0xb0, 0x13, 0x14, 0x9d, 0x51, 0x82, 0x63, 0xa5, 0x06, 0xf5, + 0xe3, 0x4a, 0x70, 0x4f, 0x47, 0x67, 0xae, 0xde, 0x16, 0xd0, 0xc6, 0x81, 0xb8, 0x35, 0x13, 0xc5, + 0xb5, 0xfe, 0x58, 0x01, 0x9b, 0x36, 0x95, 0xfb, 0x1c, 0x6c, 0xa8, 0x69, 0xb4, 0xab, 0xfd, 0xe4, + 0xa6, 0xe3, 0x68, 0xc3, 0x05, 0x6a, 0xb4, 0x35, 0x78, 0x02, 0x76, 0xac, 0x37, 0x42, 0x46, 0xa2, + 0xc4, 0xe2, 0xf3, 0x72, 0x12, 0xeb, 0x3d, 0x52, 0x46, 0xb6, 0xa5, 0xc3, 0x84, 0x42, 0x68, 0xce, + 0xef, 0x80, 0x6b, 0x48, 0x84, 0x26, 0x54, 0x1a, 0xf1, 0xe8, 0x76, 0x1a, 0x61, 0xb3, 0x19, 0xca, + 0xa3, 0xb9, 0x9e, 0x82, 0x9a, 0x90, 0x07, 0x4d, 0xa2, 0xf4, 0xe1, 0xc1, 0xcd, 0xf4, 0xa1, 0x80, + 0x2e, 0x74, 0xc6, 0xe8, 0x89, 0x9a, 0x6e, 0x0d, 0xbc, 0xbc, 0xa0, 0x27, 0x05, 0x01, 0x2f, 0xf6, + 0x44, 0xba, 0x35, 0xf8, 0x1c, 0xbc, 0x59, 0x10, 0x70, 0xcd, 0xa2, 0xe4, 0xe2, 0x8b, 0x5b, 0x2b, + 0x78, 0x81, 0x6e, 0xdb, 0x12, 0x6e, 0xe3, 0x51, 0x09, 0x65, 0xd2, 0x5c, 0xab, 0x0b, 0x1e, 0x95, + 0x25, 0x4d, 0xc5, 0x47, 0x35, 0x42, 0x59, 0x07, 0x18, 0xd8, 0xb1, 0xc5, 0x49, 0x13, 0xac, 0x2d, + 0x98, 0xb0, 0x12, 0x75, 0x2a, 0xde, 0xc5, 0x0a, 0x4b, 0xad, 0xed, 0x17, 0x55, 0x50, 0xff, 0x7a, + 0x8e, 0x92, 0x8b, 0x13, 0x94, 0x9c, 0xe3, 0x08, 0xb9, 0xbc, 0xf8, 0x06, 0xfe, 0xf8, 0xe6, 0x9a, + 0xa2, 0x14, 0xad, 0x71, 0x70, 0x8b, 0x8c, 0x54, 0xd0, 0x7e, 0x72, 0xc0, 0xf6, 0xeb, 0xbe, 0x48, + 0xdc, 0x87, 0xd7, 0x61, 0x5d, 0xf3, 0x85, 0xd4, 0xf8, 0xf4, 0xf6, 0x89, 0xaa, 0x96, 0xde, 0x2f, + 0xd5, 0x3f, 0x2f, 0x9b, 0xce, 0xcb, 0xcb, 0xa6, 0xf3, 0xef, 0x65, 0xd3, 0x79, 0x71, 0xd5, 0xac, + 0xbc, 0xbc, 0x6a, 0x56, 0xfe, 0xbe, 0x6a, 0x56, 0x40, 0x33, 0x22, 0xb3, 0x6b, 0x70, 0x7b, 0x6b, + 0xe2, 0x76, 0xe2, 0xfb, 0xad, 0xef, 0x3c, 0x0b, 0xc6, 0x98, 0x4f, 0xe6, 0xa1, 0xe8, 0x93, 0x1f, + 0x11, 0x36, 0x23, 0xcc, 0x4f, 0xd0, 0x14, 0x5e, 0xa0, 0xc4, 0x3f, 0x6f, 0x67, 0x3f, 0xe5, 0x3c, + 0x33, 0xbf, 0xfc, 0x9f, 0xc3, 0x23, 0x48, 0xa9, 0xfe, 0xfd, 0x6b, 0x75, 0xa9, 0x7f, 0xd8, 0xfd, + 0xad, 0xda, 0xe8, 0xeb, 0x12, 0x0e, 0x45, 0x09, 0x5d, 0x4a, 0xbd, 0x6f, 0xd3, 0x90, 0xbf, 0x72, + 0xe7, 0xa9, 0x70, 0x9e, 0x76, 0x29, 0x3d, 0xd5, 0xce, 0xcb, 0xea, 0x07, 0xe5, 0xce, 0xd3, 0xa3, + 0x7e, 0xef, 0x2b, 0xc4, 0xe1, 0x10, 0x72, 0xf8, 0x5f, 0xf5, 0x5d, 0x1d, 0xd8, 0xe9, 0x88, 0xc8, + 0x4e, 0xa7, 0x4b, 0x69, 0xa7, 0xa3, 0x63, 0xc3, 0x15, 0xf9, 0x95, 0x7a, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x6c, 0x62, 0x5e, 0xa0, 0xf3, 0x0c, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + // Gets the app parameters. + AppParameters(ctx context.Context, in *AppParametersRequest, opts ...grpc.CallOption) (*AppParametersResponse, error) + // Returns the CometBFT transactions that occurred during a given block. + TransactionsByHeight(ctx context.Context, in *TransactionsByHeightRequest, opts ...grpc.CallOption) (*TransactionsByHeightResponse, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) AppParameters(ctx context.Context, in *AppParametersRequest, opts ...grpc.CallOption) (*AppParametersResponse, error) { + out := new(AppParametersResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.app.v1alpha1.QueryService/AppParameters", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) TransactionsByHeight(ctx context.Context, in *TransactionsByHeightRequest, opts ...grpc.CallOption) (*TransactionsByHeightResponse, error) { + out := new(TransactionsByHeightResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.app.v1alpha1.QueryService/TransactionsByHeight", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + // Gets the app parameters. + AppParameters(context.Context, *AppParametersRequest) (*AppParametersResponse, error) + // Returns the CometBFT transactions that occurred during a given block. + TransactionsByHeight(context.Context, *TransactionsByHeightRequest) (*TransactionsByHeightResponse, error) +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) AppParameters(ctx context.Context, req *AppParametersRequest) (*AppParametersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AppParameters not implemented") +} +func (*UnimplementedQueryServiceServer) TransactionsByHeight(ctx context.Context, req *TransactionsByHeightRequest) (*TransactionsByHeightResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TransactionsByHeight not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_AppParameters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AppParametersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).AppParameters(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.app.v1alpha1.QueryService/AppParameters", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).AppParameters(ctx, req.(*AppParametersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_TransactionsByHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TransactionsByHeightRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).TransactionsByHeight(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.app.v1alpha1.QueryService/TransactionsByHeight", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).TransactionsByHeight(ctx, req.(*TransactionsByHeightRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.app.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "AppParameters", + Handler: _QueryService_AppParameters_Handler, + }, + { + MethodName: "TransactionsByHeight", + Handler: _QueryService_TransactionsByHeight_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "penumbra/core/app/v1alpha1/app.proto", +} + +func (m *TransactionsByHeightRequest) 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 *TransactionsByHeightRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TransactionsByHeightRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.BlockHeight != 0 { + i = encodeVarintApp(dAtA, i, uint64(m.BlockHeight)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintApp(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TransactionsByHeightResponse) 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 *TransactionsByHeightResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TransactionsByHeightResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.BlockHeight != 0 { + i = encodeVarintApp(dAtA, i, uint64(m.BlockHeight)) + i-- + dAtA[i] = 0x10 + } + if len(m.Transactions) > 0 { + for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Transactions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *AppParameters) 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 *AppParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AppParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DistributionsParams != nil { + { + size, err := m.DistributionsParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.FeeParams != nil { + { + size, err := m.FeeParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.StakeParams != nil { + { + size, err := m.StakeParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.IbcParams != nil { + { + size, err := m.IbcParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.GovernanceParams != nil { + { + size, err := m.GovernanceParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.CommunityPoolParams != nil { + { + size, err := m.CommunityPoolParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.ChainParams != nil { + { + size, err := m.ChainParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AppParametersRequest) 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 *AppParametersRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AppParametersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintApp(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AppParametersResponse) 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 *AppParametersResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AppParametersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AppParameters != nil { + { + size, err := m.AppParameters.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GenesisAppState) 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 *GenesisAppState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisAppState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.GenesisAppState != nil { + { + size := m.GenesisAppState.Size() + i -= size + if _, err := m.GenesisAppState.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *GenesisAppState_GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisAppState_GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.GenesisContent != nil { + { + size, err := m.GenesisContent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *GenesisAppState_GenesisCheckpoint) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisAppState_GenesisCheckpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.GenesisCheckpoint != nil { + i -= len(m.GenesisCheckpoint) + copy(dAtA[i:], m.GenesisCheckpoint) + i = encodeVarintApp(dAtA, i, uint64(len(m.GenesisCheckpoint))) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DistributionsContent != nil { + { + size, err := m.DistributionsContent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.FeeContent != nil { + { + size, err := m.FeeContent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.CommunityPoolContent != nil { + { + size, err := m.CommunityPoolContent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.ChainContent != nil { + { + size, err := m.ChainContent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.IbcContent != nil { + { + size, err := m.IbcContent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.GovernanceContent != nil { + { + size, err := m.GovernanceContent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.ShieldedPoolContent != nil { + { + size, err := m.ShieldedPoolContent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.StakeContent != nil { + { + size, err := m.StakeContent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApp(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintApp(dAtA []byte, offset int, v uint64) int { + offset -= sovApp(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *TransactionsByHeightRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovApp(uint64(l)) + } + if m.BlockHeight != 0 { + n += 1 + sovApp(uint64(m.BlockHeight)) + } + return n +} + +func (m *TransactionsByHeightResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Transactions) > 0 { + for _, e := range m.Transactions { + l = e.Size() + n += 1 + l + sovApp(uint64(l)) + } + } + if m.BlockHeight != 0 { + n += 1 + sovApp(uint64(m.BlockHeight)) + } + return n +} + +func (m *AppParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ChainParams != nil { + l = m.ChainParams.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.CommunityPoolParams != nil { + l = m.CommunityPoolParams.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.GovernanceParams != nil { + l = m.GovernanceParams.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.IbcParams != nil { + l = m.IbcParams.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.StakeParams != nil { + l = m.StakeParams.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.FeeParams != nil { + l = m.FeeParams.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.DistributionsParams != nil { + l = m.DistributionsParams.Size() + n += 1 + l + sovApp(uint64(l)) + } + return n +} + +func (m *AppParametersRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovApp(uint64(l)) + } + return n +} + +func (m *AppParametersResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AppParameters != nil { + l = m.AppParameters.Size() + n += 1 + l + sovApp(uint64(l)) + } + return n +} + +func (m *GenesisAppState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GenesisAppState != nil { + n += m.GenesisAppState.Size() + } + return n +} + +func (m *GenesisAppState_GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GenesisContent != nil { + l = m.GenesisContent.Size() + n += 1 + l + sovApp(uint64(l)) + } + return n +} +func (m *GenesisAppState_GenesisCheckpoint) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GenesisCheckpoint != nil { + l = len(m.GenesisCheckpoint) + n += 1 + l + sovApp(uint64(l)) + } + return n +} +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StakeContent != nil { + l = m.StakeContent.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.ShieldedPoolContent != nil { + l = m.ShieldedPoolContent.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.GovernanceContent != nil { + l = m.GovernanceContent.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.IbcContent != nil { + l = m.IbcContent.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.ChainContent != nil { + l = m.ChainContent.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.CommunityPoolContent != nil { + l = m.CommunityPoolContent.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.FeeContent != nil { + l = m.FeeContent.Size() + n += 1 + l + sovApp(uint64(l)) + } + if m.DistributionsContent != nil { + l = m.DistributionsContent.Size() + n += 1 + l + sovApp(uint64(l)) + } + return n +} + +func sovApp(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozApp(x uint64) (n int) { + return sovApp(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *TransactionsByHeightRequest) 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 ErrIntOverflowApp + } + 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: TransactionsByHeightRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TransactionsByHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + 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 ErrInvalidLengthApp + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType) + } + m.BlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipApp(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApp + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TransactionsByHeightResponse) 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 ErrIntOverflowApp + } + 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: TransactionsByHeightResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TransactionsByHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Transactions = append(m.Transactions, &v1alpha1.Transaction{}) + if err := m.Transactions[len(m.Transactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType) + } + m.BlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipApp(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApp + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppParameters) 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 ErrIntOverflowApp + } + 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: AppParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChainParams == nil { + m.ChainParams = &v1alpha11.ChainParameters{} + } + if err := m.ChainParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CommunityPoolParams == nil { + m.CommunityPoolParams = &v1alpha12.CommunityPoolParameters{} + } + if err := m.CommunityPoolParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GovernanceParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GovernanceParams == nil { + m.GovernanceParams = &v1alpha13.GovernanceParameters{} + } + if err := m.GovernanceParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IbcParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.IbcParams == nil { + m.IbcParams = &v1alpha14.IbcParameters{} + } + if err := m.IbcParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StakeParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StakeParams == nil { + m.StakeParams = &v1alpha15.StakeParameters{} + } + if err := m.StakeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FeeParams == nil { + m.FeeParams = &v1alpha16.FeeParameters{} + } + if err := m.FeeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DistributionsParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DistributionsParams == nil { + m.DistributionsParams = &v1alpha17.DistributionsParameters{} + } + if err := m.DistributionsParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApp(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApp + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppParametersRequest) 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 ErrIntOverflowApp + } + 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: AppParametersRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + 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 ErrInvalidLengthApp + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApp(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApp + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppParametersResponse) 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 ErrIntOverflowApp + } + 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: AppParametersResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AppParameters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AppParameters == nil { + m.AppParameters = &AppParameters{} + } + if err := m.AppParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApp(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApp + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisAppState) 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 ErrIntOverflowApp + } + 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: GenesisAppState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisAppState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GenesisContent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &GenesisContent{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.GenesisAppState = &GenesisAppState_GenesisContent{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GenesisCheckpoint", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, dAtA[iNdEx:postIndex]) + m.GenesisAppState = &GenesisAppState_GenesisCheckpoint{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApp(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApp + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent) 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 ErrIntOverflowApp + } + 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: GenesisContent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StakeContent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StakeContent == nil { + m.StakeContent = &v1alpha15.GenesisContent{} + } + if err := m.StakeContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ShieldedPoolContent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ShieldedPoolContent == nil { + m.ShieldedPoolContent = &v1alpha18.GenesisContent{} + } + if err := m.ShieldedPoolContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GovernanceContent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GovernanceContent == nil { + m.GovernanceContent = &v1alpha13.GenesisContent{} + } + if err := m.GovernanceContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IbcContent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.IbcContent == nil { + m.IbcContent = &v1alpha14.GenesisContent{} + } + if err := m.IbcContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainContent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChainContent == nil { + m.ChainContent = &v1alpha11.GenesisContent{} + } + if err := m.ChainContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolContent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CommunityPoolContent == nil { + m.CommunityPoolContent = &v1alpha12.GenesisContent{} + } + if err := m.CommunityPoolContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeContent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FeeContent == nil { + m.FeeContent = &v1alpha16.GenesisContent{} + } + if err := m.FeeContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DistributionsContent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApp + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApp + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApp + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DistributionsContent == nil { + m.DistributionsContent = &v1alpha17.GenesisContent{} + } + if err := m.DistributionsContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApp(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApp + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipApp(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, ErrIntOverflowApp + } + 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, ErrIntOverflowApp + } + 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, ErrIntOverflowApp + } + 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, ErrInvalidLengthApp + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupApp + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthApp + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthApp = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowApp = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupApp = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/asset/v1alpha1/asset.pb.go b/relayer/chains/penumbra/core/asset/v1alpha1/asset.pb.go new file mode 100644 index 000000000..6f5890373 --- /dev/null +++ b/relayer/chains/penumbra/core/asset/v1alpha1/asset.pb.go @@ -0,0 +1,2737 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/asset/v1alpha1/asset.proto + +package assetv1alpha1 + +import ( + fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" + 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 + +type BalanceCommitment struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *BalanceCommitment) Reset() { *m = BalanceCommitment{} } +func (m *BalanceCommitment) String() string { return proto.CompactTextString(m) } +func (*BalanceCommitment) ProtoMessage() {} +func (*BalanceCommitment) Descriptor() ([]byte, []int) { + return fileDescriptor_dbd1fa7252b11f51, []int{0} +} +func (m *BalanceCommitment) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BalanceCommitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BalanceCommitment.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 *BalanceCommitment) XXX_Merge(src proto.Message) { + xxx_messageInfo_BalanceCommitment.Merge(m, src) +} +func (m *BalanceCommitment) XXX_Size() int { + return m.Size() +} +func (m *BalanceCommitment) XXX_DiscardUnknown() { + xxx_messageInfo_BalanceCommitment.DiscardUnknown(m) +} + +var xxx_messageInfo_BalanceCommitment proto.InternalMessageInfo + +func (m *BalanceCommitment) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// A Penumbra asset ID. +type AssetId struct { + // The bytes of the asset ID. + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` + // Alternatively, a Bech32m-encoded string representation of the `inner` + // bytes. + // + // NOTE: implementations are not required to support parsing this field. + // Implementations should prefer to encode the `inner` bytes in all messages they + // produce. Implementations must not accept messages with both `inner` and + // `alt_bech32m` set. This field exists for convenience of RPC users. + AltBech32M string `protobuf:"bytes,2,opt,name=alt_bech32m,json=altBech32m,proto3" json:"alt_bech32m,omitempty"` + // Alternatively, a base denomination string which should be hashed to obtain the asset ID. + // + // NOTE: implementations are not required to support parsing this field. + // Implementations should prefer to encode the bytes in all messages they + // produce. Implementations must not accept messages with both `inner` and + // `alt_base_denom` set. This field exists for convenience of RPC users. + AltBaseDenom string `protobuf:"bytes,3,opt,name=alt_base_denom,json=altBaseDenom,proto3" json:"alt_base_denom,omitempty"` +} + +func (m *AssetId) Reset() { *m = AssetId{} } +func (m *AssetId) String() string { return proto.CompactTextString(m) } +func (*AssetId) ProtoMessage() {} +func (*AssetId) Descriptor() ([]byte, []int) { + return fileDescriptor_dbd1fa7252b11f51, []int{1} +} +func (m *AssetId) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AssetId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AssetId.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 *AssetId) XXX_Merge(src proto.Message) { + xxx_messageInfo_AssetId.Merge(m, src) +} +func (m *AssetId) XXX_Size() int { + return m.Size() +} +func (m *AssetId) XXX_DiscardUnknown() { + xxx_messageInfo_AssetId.DiscardUnknown(m) +} + +var xxx_messageInfo_AssetId proto.InternalMessageInfo + +func (m *AssetId) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +func (m *AssetId) GetAltBech32M() string { + if m != nil { + return m.AltBech32M + } + return "" +} + +func (m *AssetId) GetAltBaseDenom() string { + if m != nil { + return m.AltBaseDenom + } + return "" +} + +type Denom struct { + Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` +} + +func (m *Denom) Reset() { *m = Denom{} } +func (m *Denom) String() string { return proto.CompactTextString(m) } +func (*Denom) ProtoMessage() {} +func (*Denom) Descriptor() ([]byte, []int) { + return fileDescriptor_dbd1fa7252b11f51, []int{2} +} +func (m *Denom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Denom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Denom.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 *Denom) XXX_Merge(src proto.Message) { + xxx_messageInfo_Denom.Merge(m, src) +} +func (m *Denom) XXX_Size() int { + return m.Size() +} +func (m *Denom) XXX_DiscardUnknown() { + xxx_messageInfo_Denom.DiscardUnknown(m) +} + +var xxx_messageInfo_Denom proto.InternalMessageInfo + +func (m *Denom) GetDenom() string { + if m != nil { + return m.Denom + } + return "" +} + +// DenomMetadata represents a struct that describes a basic token. +type DenomMetadata struct { + Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"` + // denom_units represents the list of DenomUnit's for a given coin + DenomUnits []*DenomUnit `protobuf:"bytes,2,rep,name=denom_units,json=denomUnits,proto3" json:"denom_units,omitempty"` + // base represents the base denom (should be the DenomUnit with exponent = 0). + Base string `protobuf:"bytes,3,opt,name=base,proto3" json:"base,omitempty"` + // display indicates the suggested denom that should be + // displayed in clients. + Display string `protobuf:"bytes,4,opt,name=display,proto3" json:"display,omitempty"` + // name defines the name of the token (eg: Cosmos Atom) + Name string `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"` + // symbol is the token symbol usually shown on exchanges (eg: ATOM). This can + // be the same as the display. + Symbol string `protobuf:"bytes,6,opt,name=symbol,proto3" json:"symbol,omitempty"` + // URI to a document (on or off-chain) that contains additional information. Optional. + Uri string `protobuf:"bytes,7,opt,name=uri,proto3" json:"uri,omitempty"` + // URIHash is a sha256 hash of a document pointed by URI. It's used to verify that + // the document didn't change. Optional. + UriHash string `protobuf:"bytes,8,opt,name=uri_hash,json=uriHash,proto3" json:"uri_hash,omitempty"` + // the asset ID on Penumbra for this denomination. + PenumbraAssetId *AssetId `protobuf:"bytes,1984,opt,name=penumbra_asset_id,json=penumbraAssetId,proto3" json:"penumbra_asset_id,omitempty"` +} + +func (m *DenomMetadata) Reset() { *m = DenomMetadata{} } +func (m *DenomMetadata) String() string { return proto.CompactTextString(m) } +func (*DenomMetadata) ProtoMessage() {} +func (*DenomMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_dbd1fa7252b11f51, []int{3} +} +func (m *DenomMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DenomMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DenomMetadata.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 *DenomMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_DenomMetadata.Merge(m, src) +} +func (m *DenomMetadata) XXX_Size() int { + return m.Size() +} +func (m *DenomMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_DenomMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_DenomMetadata proto.InternalMessageInfo + +func (m *DenomMetadata) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *DenomMetadata) GetDenomUnits() []*DenomUnit { + if m != nil { + return m.DenomUnits + } + return nil +} + +func (m *DenomMetadata) GetBase() string { + if m != nil { + return m.Base + } + return "" +} + +func (m *DenomMetadata) GetDisplay() string { + if m != nil { + return m.Display + } + return "" +} + +func (m *DenomMetadata) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *DenomMetadata) GetSymbol() string { + if m != nil { + return m.Symbol + } + return "" +} + +func (m *DenomMetadata) GetUri() string { + if m != nil { + return m.Uri + } + return "" +} + +func (m *DenomMetadata) GetUriHash() string { + if m != nil { + return m.UriHash + } + return "" +} + +func (m *DenomMetadata) GetPenumbraAssetId() *AssetId { + if m != nil { + return m.PenumbraAssetId + } + return nil +} + +// DenomUnit represents a struct that describes a given denomination unit of the basic token. +type DenomUnit struct { + // denom represents the string name of the given denom unit (e.g uatom). + Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` + // exponent represents power of 10 exponent that one must + // raise the base_denom to in order to equal the given DenomUnit's denom + // 1 denom = 10^exponent base_denom + // (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with + // exponent = 6, thus: 1 atom = 10^6 uatom). + Exponent uint32 `protobuf:"varint,2,opt,name=exponent,proto3" json:"exponent,omitempty"` + // aliases is a list of string aliases for the given denom + Aliases []string `protobuf:"bytes,3,rep,name=aliases,proto3" json:"aliases,omitempty"` +} + +func (m *DenomUnit) Reset() { *m = DenomUnit{} } +func (m *DenomUnit) String() string { return proto.CompactTextString(m) } +func (*DenomUnit) ProtoMessage() {} +func (*DenomUnit) Descriptor() ([]byte, []int) { + return fileDescriptor_dbd1fa7252b11f51, []int{4} +} +func (m *DenomUnit) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DenomUnit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DenomUnit.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 *DenomUnit) XXX_Merge(src proto.Message) { + xxx_messageInfo_DenomUnit.Merge(m, src) +} +func (m *DenomUnit) XXX_Size() int { + return m.Size() +} +func (m *DenomUnit) XXX_DiscardUnknown() { + xxx_messageInfo_DenomUnit.DiscardUnknown(m) +} + +var xxx_messageInfo_DenomUnit proto.InternalMessageInfo + +func (m *DenomUnit) GetDenom() string { + if m != nil { + return m.Denom + } + return "" +} + +func (m *DenomUnit) GetExponent() uint32 { + if m != nil { + return m.Exponent + } + return 0 +} + +func (m *DenomUnit) GetAliases() []string { + if m != nil { + return m.Aliases + } + return nil +} + +type Value struct { + Amount *v1alpha1.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` + AssetId *AssetId `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` +} + +func (m *Value) Reset() { *m = Value{} } +func (m *Value) String() string { return proto.CompactTextString(m) } +func (*Value) ProtoMessage() {} +func (*Value) Descriptor() ([]byte, []int) { + return fileDescriptor_dbd1fa7252b11f51, []int{5} +} +func (m *Value) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Value.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 *Value) XXX_Merge(src proto.Message) { + xxx_messageInfo_Value.Merge(m, src) +} +func (m *Value) XXX_Size() int { + return m.Size() +} +func (m *Value) XXX_DiscardUnknown() { + xxx_messageInfo_Value.DiscardUnknown(m) +} + +var xxx_messageInfo_Value proto.InternalMessageInfo + +func (m *Value) GetAmount() *v1alpha1.Amount { + if m != nil { + return m.Amount + } + return nil +} + +func (m *Value) GetAssetId() *AssetId { + if m != nil { + return m.AssetId + } + return nil +} + +// Represents a value of a known or unknown denomination. +// +// Note: unlike some other View types, we don't just store the underlying +// `Value` message together with an additional `Denom`. Instead, we record +// either an `Amount` and `Denom` (only) or an `Amount` and `AssetId`. This is +// because we don't want to allow a situation where the supplied `Denom` doesn't +// match the `AssetId`, and a consumer of the API that doesn't check is tricked. +// This way, the `Denom` will always match, because the consumer is forced to +// recompute it themselves if they want it. +type ValueView struct { + // Types that are valid to be assigned to ValueView: + // + // *ValueView_KnownDenom_ + // *ValueView_UnknownDenom_ + ValueView isValueView_ValueView `protobuf_oneof:"value_view"` +} + +func (m *ValueView) Reset() { *m = ValueView{} } +func (m *ValueView) String() string { return proto.CompactTextString(m) } +func (*ValueView) ProtoMessage() {} +func (*ValueView) Descriptor() ([]byte, []int) { + return fileDescriptor_dbd1fa7252b11f51, []int{6} +} +func (m *ValueView) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValueView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValueView.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 *ValueView) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValueView.Merge(m, src) +} +func (m *ValueView) XXX_Size() int { + return m.Size() +} +func (m *ValueView) XXX_DiscardUnknown() { + xxx_messageInfo_ValueView.DiscardUnknown(m) +} + +var xxx_messageInfo_ValueView proto.InternalMessageInfo + +type isValueView_ValueView interface { + isValueView_ValueView() + MarshalTo([]byte) (int, error) + Size() int +} + +type ValueView_KnownDenom_ struct { + KnownDenom *ValueView_KnownDenom `protobuf:"bytes,1,opt,name=known_denom,json=knownDenom,proto3,oneof" json:"known_denom,omitempty"` +} +type ValueView_UnknownDenom_ struct { + UnknownDenom *ValueView_UnknownDenom `protobuf:"bytes,2,opt,name=unknown_denom,json=unknownDenom,proto3,oneof" json:"unknown_denom,omitempty"` +} + +func (*ValueView_KnownDenom_) isValueView_ValueView() {} +func (*ValueView_UnknownDenom_) isValueView_ValueView() {} + +func (m *ValueView) GetValueView() isValueView_ValueView { + if m != nil { + return m.ValueView + } + return nil +} + +func (m *ValueView) GetKnownDenom() *ValueView_KnownDenom { + if x, ok := m.GetValueView().(*ValueView_KnownDenom_); ok { + return x.KnownDenom + } + return nil +} + +func (m *ValueView) GetUnknownDenom() *ValueView_UnknownDenom { + if x, ok := m.GetValueView().(*ValueView_UnknownDenom_); ok { + return x.UnknownDenom + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ValueView) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ValueView_KnownDenom_)(nil), + (*ValueView_UnknownDenom_)(nil), + } +} + +// A value whose asset ID has a known denomination. +type ValueView_KnownDenom struct { + Amount *v1alpha1.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` + Denom *DenomMetadata `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"` +} + +func (m *ValueView_KnownDenom) Reset() { *m = ValueView_KnownDenom{} } +func (m *ValueView_KnownDenom) String() string { return proto.CompactTextString(m) } +func (*ValueView_KnownDenom) ProtoMessage() {} +func (*ValueView_KnownDenom) Descriptor() ([]byte, []int) { + return fileDescriptor_dbd1fa7252b11f51, []int{6, 0} +} +func (m *ValueView_KnownDenom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValueView_KnownDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValueView_KnownDenom.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 *ValueView_KnownDenom) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValueView_KnownDenom.Merge(m, src) +} +func (m *ValueView_KnownDenom) XXX_Size() int { + return m.Size() +} +func (m *ValueView_KnownDenom) XXX_DiscardUnknown() { + xxx_messageInfo_ValueView_KnownDenom.DiscardUnknown(m) +} + +var xxx_messageInfo_ValueView_KnownDenom proto.InternalMessageInfo + +func (m *ValueView_KnownDenom) GetAmount() *v1alpha1.Amount { + if m != nil { + return m.Amount + } + return nil +} + +func (m *ValueView_KnownDenom) GetDenom() *DenomMetadata { + if m != nil { + return m.Denom + } + return nil +} + +type ValueView_UnknownDenom struct { + Amount *v1alpha1.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` + AssetId *AssetId `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` +} + +func (m *ValueView_UnknownDenom) Reset() { *m = ValueView_UnknownDenom{} } +func (m *ValueView_UnknownDenom) String() string { return proto.CompactTextString(m) } +func (*ValueView_UnknownDenom) ProtoMessage() {} +func (*ValueView_UnknownDenom) Descriptor() ([]byte, []int) { + return fileDescriptor_dbd1fa7252b11f51, []int{6, 1} +} +func (m *ValueView_UnknownDenom) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValueView_UnknownDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValueView_UnknownDenom.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 *ValueView_UnknownDenom) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValueView_UnknownDenom.Merge(m, src) +} +func (m *ValueView_UnknownDenom) XXX_Size() int { + return m.Size() +} +func (m *ValueView_UnknownDenom) XXX_DiscardUnknown() { + xxx_messageInfo_ValueView_UnknownDenom.DiscardUnknown(m) +} + +var xxx_messageInfo_ValueView_UnknownDenom proto.InternalMessageInfo + +func (m *ValueView_UnknownDenom) GetAmount() *v1alpha1.Amount { + if m != nil { + return m.Amount + } + return nil +} + +func (m *ValueView_UnknownDenom) GetAssetId() *AssetId { + if m != nil { + return m.AssetId + } + return nil +} + +func init() { + proto.RegisterType((*BalanceCommitment)(nil), "penumbra.core.asset.v1alpha1.BalanceCommitment") + proto.RegisterType((*AssetId)(nil), "penumbra.core.asset.v1alpha1.AssetId") + proto.RegisterType((*Denom)(nil), "penumbra.core.asset.v1alpha1.Denom") + proto.RegisterType((*DenomMetadata)(nil), "penumbra.core.asset.v1alpha1.DenomMetadata") + proto.RegisterType((*DenomUnit)(nil), "penumbra.core.asset.v1alpha1.DenomUnit") + proto.RegisterType((*Value)(nil), "penumbra.core.asset.v1alpha1.Value") + proto.RegisterType((*ValueView)(nil), "penumbra.core.asset.v1alpha1.ValueView") + proto.RegisterType((*ValueView_KnownDenom)(nil), "penumbra.core.asset.v1alpha1.ValueView.KnownDenom") + proto.RegisterType((*ValueView_UnknownDenom)(nil), "penumbra.core.asset.v1alpha1.ValueView.UnknownDenom") +} + +func init() { + proto.RegisterFile("penumbra/core/asset/v1alpha1/asset.proto", fileDescriptor_dbd1fa7252b11f51) +} + +var fileDescriptor_dbd1fa7252b11f51 = []byte{ + // 717 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x55, 0xcd, 0x6e, 0xd3, 0x4a, + 0x14, 0x8e, 0x9d, 0xe6, 0xa7, 0x27, 0xe9, 0xed, 0xed, 0xe8, 0xea, 0xca, 0x37, 0xea, 0x4d, 0xa3, + 0xa8, 0x88, 0x20, 0x24, 0x47, 0x4d, 0x59, 0x85, 0x0d, 0x4d, 0x91, 0x28, 0x42, 0x48, 0x91, 0xa5, + 0x06, 0x09, 0x22, 0x59, 0x13, 0x67, 0xc0, 0xa3, 0x7a, 0x66, 0x22, 0x8f, 0x9d, 0xd2, 0x07, 0x60, + 0x05, 0x0b, 0x9e, 0x81, 0x25, 0x3b, 0xde, 0x80, 0x25, 0x62, 0xd5, 0x15, 0x62, 0x89, 0xd2, 0x5d, + 0x9f, 0x02, 0xcd, 0xd8, 0x4e, 0x02, 0xaa, 0xa2, 0x22, 0x16, 0xec, 0xce, 0x77, 0xce, 0x37, 0xdf, + 0x7c, 0xe7, 0x1c, 0xff, 0x40, 0x6b, 0x42, 0x78, 0xcc, 0x46, 0x21, 0x6e, 0x7b, 0x22, 0x24, 0x6d, + 0x2c, 0x25, 0x89, 0xda, 0xd3, 0x3d, 0x1c, 0x4c, 0x7c, 0xbc, 0x97, 0x40, 0x7b, 0x12, 0x8a, 0x48, + 0xa0, 0xed, 0x8c, 0x69, 0x2b, 0xa6, 0x9d, 0x94, 0x32, 0x66, 0x6d, 0xf7, 0x47, 0x1d, 0x1e, 0xb3, + 0x85, 0x0a, 0x8f, 0x59, 0xa2, 0xd1, 0xbc, 0x05, 0x5b, 0x3d, 0x1c, 0x60, 0xee, 0x91, 0x43, 0xc1, + 0x18, 0x8d, 0x18, 0xe1, 0x11, 0xfa, 0x07, 0x0a, 0x94, 0x73, 0x12, 0x5a, 0x46, 0xc3, 0x68, 0x55, + 0x9d, 0x04, 0x34, 0x9f, 0x43, 0xe9, 0x40, 0x5d, 0xf1, 0x70, 0x7c, 0x35, 0x01, 0xed, 0x40, 0x05, + 0x07, 0x91, 0x3b, 0x22, 0x9e, 0xbf, 0xdf, 0x61, 0x96, 0xd9, 0x30, 0x5a, 0xeb, 0x0e, 0xe0, 0x20, + 0xea, 0x25, 0x19, 0xb4, 0x0b, 0x7f, 0x69, 0x02, 0x96, 0xc4, 0x1d, 0x13, 0x2e, 0x98, 0x95, 0xd7, + 0x9c, 0xaa, 0xe2, 0x60, 0x49, 0xee, 0xab, 0x5c, 0xf3, 0x7f, 0x28, 0xe8, 0x40, 0xdd, 0x92, 0xb0, + 0x0c, 0xcd, 0x4a, 0x40, 0xf3, 0x8b, 0x09, 0x1b, 0xba, 0xfe, 0x98, 0x44, 0x78, 0x8c, 0x23, 0x8c, + 0x1a, 0x50, 0x19, 0x13, 0xe9, 0x85, 0x74, 0x12, 0x51, 0xc1, 0x53, 0xf6, 0x72, 0x0a, 0x1d, 0x29, + 0x06, 0x17, 0xcc, 0x8d, 0x39, 0x8d, 0xa4, 0x65, 0x36, 0xf2, 0xad, 0x4a, 0xe7, 0xa6, 0xbd, 0x6a, + 0x7e, 0xb6, 0xbe, 0xe3, 0x98, 0xd3, 0xc8, 0x81, 0x71, 0x16, 0x4a, 0x84, 0x60, 0x4d, 0xd9, 0x4f, + 0x8d, 0xeb, 0x18, 0x59, 0x50, 0x1a, 0x53, 0x39, 0x09, 0xf0, 0x99, 0xb5, 0xa6, 0xd3, 0x19, 0x54, + 0x6c, 0x8e, 0x19, 0xb1, 0x0a, 0x09, 0x5b, 0xc5, 0xe8, 0x5f, 0x28, 0xca, 0x33, 0x36, 0x12, 0x81, + 0x55, 0xd4, 0xd9, 0x14, 0xa1, 0xbf, 0x21, 0x1f, 0x87, 0xd4, 0x2a, 0xe9, 0xa4, 0x0a, 0xd1, 0x7f, + 0x50, 0x8e, 0x43, 0xea, 0xfa, 0x58, 0xfa, 0x56, 0x39, 0x11, 0x8e, 0x43, 0x7a, 0x84, 0xa5, 0x8f, + 0x1c, 0xd8, 0xca, 0xcc, 0xbb, 0xda, 0xb7, 0x4b, 0xc7, 0xd6, 0xc7, 0xcd, 0x86, 0xd1, 0xaa, 0x74, + 0x6e, 0xac, 0xee, 0x2b, 0xdd, 0xa1, 0xb3, 0x99, 0xb1, 0xd2, 0x44, 0xf3, 0x09, 0xac, 0xcf, 0x7b, + 0xbe, 0x7a, 0xf6, 0xa8, 0x06, 0x65, 0xf2, 0x72, 0x22, 0x38, 0xe1, 0x91, 0x5e, 0xef, 0x86, 0x33, + 0xc7, 0x6a, 0x0a, 0x38, 0xa0, 0x58, 0x12, 0x69, 0xe5, 0x1b, 0x79, 0x65, 0x36, 0x85, 0xcd, 0x57, + 0x06, 0x14, 0x06, 0x38, 0x88, 0x09, 0xea, 0x42, 0x11, 0x33, 0x11, 0xf3, 0x48, 0xcb, 0x56, 0x3a, + 0xcd, 0x9f, 0xac, 0xaa, 0xe7, 0x72, 0x61, 0x54, 0x33, 0x9d, 0xf4, 0x04, 0xba, 0x07, 0xe5, 0x79, + 0xa7, 0xe6, 0xaf, 0x34, 0x5a, 0xc2, 0x69, 0x83, 0x97, 0x79, 0x58, 0xd7, 0x3e, 0x06, 0x94, 0x9c, + 0xa2, 0x63, 0xa8, 0x9c, 0x70, 0x71, 0xca, 0xdd, 0x45, 0x9f, 0x95, 0x4e, 0x67, 0xb5, 0xe4, 0xfc, + 0xb4, 0xfd, 0x48, 0x1d, 0xd5, 0xe3, 0x3a, 0xca, 0x39, 0x70, 0x32, 0x47, 0xe8, 0x19, 0x6c, 0xc4, + 0x7c, 0x59, 0x38, 0xf1, 0x7a, 0xe7, 0xba, 0xc2, 0xc7, 0xfc, 0x64, 0x59, 0xba, 0x1a, 0x2f, 0xe1, + 0xda, 0x6b, 0x03, 0x60, 0x71, 0xf3, 0x6f, 0x8d, 0xf3, 0x20, 0x5b, 0x70, 0xe2, 0xef, 0xf6, 0x35, + 0x5e, 0x86, 0xec, 0x85, 0x4b, 0x9f, 0x86, 0xda, 0x1b, 0x03, 0xaa, 0xcb, 0x76, 0xff, 0xec, 0x7a, + 0x7b, 0x55, 0x80, 0xa9, 0x1a, 0xa3, 0x3b, 0xa5, 0xe4, 0xb4, 0xf7, 0xc1, 0xfc, 0x34, 0xab, 0x1b, + 0xe7, 0xb3, 0xba, 0xf1, 0x6d, 0x56, 0x37, 0xde, 0x5e, 0xd4, 0x73, 0xe7, 0x17, 0xf5, 0xdc, 0xd7, + 0x8b, 0x7a, 0x0e, 0x1a, 0x9e, 0x60, 0x2b, 0xb5, 0x7b, 0xa0, 0xc5, 0xfb, 0xea, 0x0b, 0xd9, 0x37, + 0x9e, 0x0e, 0x5e, 0xd0, 0xc8, 0x8f, 0x47, 0xb6, 0x27, 0x58, 0xdb, 0x13, 0x92, 0x09, 0xd9, 0x0e, + 0x49, 0x80, 0xcf, 0x48, 0xd8, 0x9e, 0x76, 0xe6, 0xa1, 0xe7, 0x63, 0xca, 0x65, 0x7b, 0xd5, 0xd7, + 0xfb, 0xae, 0x86, 0x19, 0x7a, 0x67, 0xe6, 0xfb, 0x87, 0x07, 0xef, 0xcd, 0xed, 0x7e, 0x66, 0xe5, + 0x50, 0x59, 0xd1, 0x57, 0xdb, 0x83, 0x94, 0xf4, 0x79, 0x51, 0x1e, 0xaa, 0xf2, 0x50, 0x97, 0x87, + 0x59, 0x79, 0x66, 0xb6, 0x56, 0x95, 0x87, 0x0f, 0xfa, 0xbd, 0x6c, 0x6b, 0x97, 0xe6, 0x4e, 0x46, + 0xed, 0x76, 0x15, 0xb7, 0xdb, 0xd5, 0xe4, 0x6e, 0x37, 0x63, 0x8f, 0x8a, 0xfa, 0x9f, 0xb0, 0xff, + 0x3d, 0x00, 0x00, 0xff, 0xff, 0x80, 0x24, 0x64, 0x6d, 0x83, 0x06, 0x00, 0x00, +} + +func (m *BalanceCommitment) 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 *BalanceCommitment) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BalanceCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AssetId) 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 *AssetId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AssetId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AltBaseDenom) > 0 { + i -= len(m.AltBaseDenom) + copy(dAtA[i:], m.AltBaseDenom) + i = encodeVarintAsset(dAtA, i, uint64(len(m.AltBaseDenom))) + i-- + dAtA[i] = 0x1a + } + if len(m.AltBech32M) > 0 { + i -= len(m.AltBech32M) + copy(dAtA[i:], m.AltBech32M) + i = encodeVarintAsset(dAtA, i, uint64(len(m.AltBech32M))) + i-- + dAtA[i] = 0x12 + } + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Denom) 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 *Denom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Denom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DenomMetadata) 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 *DenomMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DenomMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.PenumbraAssetId != nil { + { + size, err := m.PenumbraAssetId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x7c + i-- + dAtA[i] = 0x82 + } + if len(m.UriHash) > 0 { + i -= len(m.UriHash) + copy(dAtA[i:], m.UriHash) + i = encodeVarintAsset(dAtA, i, uint64(len(m.UriHash))) + i-- + dAtA[i] = 0x42 + } + if len(m.Uri) > 0 { + i -= len(m.Uri) + copy(dAtA[i:], m.Uri) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Uri))) + i-- + dAtA[i] = 0x3a + } + if len(m.Symbol) > 0 { + i -= len(m.Symbol) + copy(dAtA[i:], m.Symbol) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Symbol))) + i-- + dAtA[i] = 0x32 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x2a + } + if len(m.Display) > 0 { + i -= len(m.Display) + copy(dAtA[i:], m.Display) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Display))) + i-- + dAtA[i] = 0x22 + } + if len(m.Base) > 0 { + i -= len(m.Base) + copy(dAtA[i:], m.Base) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Base))) + i-- + dAtA[i] = 0x1a + } + if len(m.DenomUnits) > 0 { + for iNdEx := len(m.DenomUnits) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DenomUnits[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DenomUnit) 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 *DenomUnit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DenomUnit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Aliases) > 0 { + for iNdEx := len(m.Aliases) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Aliases[iNdEx]) + copy(dAtA[i:], m.Aliases[iNdEx]) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Aliases[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if m.Exponent != 0 { + i = encodeVarintAsset(dAtA, i, uint64(m.Exponent)) + i-- + dAtA[i] = 0x10 + } + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintAsset(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Value) 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 *Value) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Value) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AssetId != nil { + { + size, err := m.AssetId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Amount != nil { + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValueView) 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 *ValueView) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValueView) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ValueView != nil { + { + size := m.ValueView.Size() + i -= size + if _, err := m.ValueView.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *ValueView_KnownDenom_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValueView_KnownDenom_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.KnownDenom != nil { + { + size, err := m.KnownDenom.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *ValueView_UnknownDenom_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValueView_UnknownDenom_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.UnknownDenom != nil { + { + size, err := m.UnknownDenom.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *ValueView_KnownDenom) 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 *ValueView_KnownDenom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValueView_KnownDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Denom != nil { + { + size, err := m.Denom.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Amount != nil { + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValueView_UnknownDenom) 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 *ValueView_UnknownDenom) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValueView_UnknownDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AssetId != nil { + { + size, err := m.AssetId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Amount != nil { + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAsset(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintAsset(dAtA []byte, offset int, v uint64) int { + offset -= sovAsset(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *BalanceCommitment) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + return n +} + +func (m *AssetId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + l = len(m.AltBech32M) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + l = len(m.AltBaseDenom) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + return n +} + +func (m *Denom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + return n +} + +func (m *DenomMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Description) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + if len(m.DenomUnits) > 0 { + for _, e := range m.DenomUnits { + l = e.Size() + n += 1 + l + sovAsset(uint64(l)) + } + } + l = len(m.Base) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + l = len(m.Display) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + l = len(m.Symbol) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + l = len(m.Uri) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + l = len(m.UriHash) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + if m.PenumbraAssetId != nil { + l = m.PenumbraAssetId.Size() + n += 2 + l + sovAsset(uint64(l)) + } + return n +} + +func (m *DenomUnit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovAsset(uint64(l)) + } + if m.Exponent != 0 { + n += 1 + sovAsset(uint64(m.Exponent)) + } + if len(m.Aliases) > 0 { + for _, s := range m.Aliases { + l = len(s) + n += 1 + l + sovAsset(uint64(l)) + } + } + return n +} + +func (m *Value) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Amount != nil { + l = m.Amount.Size() + n += 1 + l + sovAsset(uint64(l)) + } + if m.AssetId != nil { + l = m.AssetId.Size() + n += 1 + l + sovAsset(uint64(l)) + } + return n +} + +func (m *ValueView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValueView != nil { + n += m.ValueView.Size() + } + return n +} + +func (m *ValueView_KnownDenom_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.KnownDenom != nil { + l = m.KnownDenom.Size() + n += 1 + l + sovAsset(uint64(l)) + } + return n +} +func (m *ValueView_UnknownDenom_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UnknownDenom != nil { + l = m.UnknownDenom.Size() + n += 1 + l + sovAsset(uint64(l)) + } + return n +} +func (m *ValueView_KnownDenom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Amount != nil { + l = m.Amount.Size() + n += 1 + l + sovAsset(uint64(l)) + } + if m.Denom != nil { + l = m.Denom.Size() + n += 1 + l + sovAsset(uint64(l)) + } + return n +} + +func (m *ValueView_UnknownDenom) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Amount != nil { + l = m.Amount.Size() + n += 1 + l + sovAsset(uint64(l)) + } + if m.AssetId != nil { + l = m.AssetId.Size() + n += 1 + l + sovAsset(uint64(l)) + } + return n +} + +func sovAsset(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozAsset(x uint64) (n int) { + return sovAsset(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *BalanceCommitment) 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 ErrIntOverflowAsset + } + 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: BalanceCommitment: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BalanceCommitment: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAsset(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAsset + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AssetId) 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 ErrIntOverflowAsset + } + 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: AssetId: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AssetId: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AltBech32M", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AltBech32M = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AltBaseDenom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AltBaseDenom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAsset(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAsset + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Denom) 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 ErrIntOverflowAsset + } + 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: Denom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Denom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAsset(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAsset + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DenomMetadata) 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 ErrIntOverflowAsset + } + 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: DenomMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DenomMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DenomUnits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DenomUnits = append(m.DenomUnits, &DenomUnit{}) + if err := m.DenomUnits[len(m.DenomUnits)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Base = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Display", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Display = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Symbol = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uri", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Uri = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UriHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UriHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 1984: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PenumbraAssetId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PenumbraAssetId == nil { + m.PenumbraAssetId = &AssetId{} + } + if err := m.PenumbraAssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAsset(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAsset + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DenomUnit) 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 ErrIntOverflowAsset + } + 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: DenomUnit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DenomUnit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Exponent", wireType) + } + m.Exponent = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Exponent |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Aliases", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + 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 ErrInvalidLengthAsset + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Aliases = append(m.Aliases, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAsset(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAsset + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Value) 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 ErrIntOverflowAsset + } + 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: Value: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Value: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Amount == nil { + m.Amount = &v1alpha1.Amount{} + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AssetId == nil { + m.AssetId = &AssetId{} + } + if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAsset(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAsset + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValueView) 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 ErrIntOverflowAsset + } + 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: ValueView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValueView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KnownDenom", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ValueView_KnownDenom{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.ValueView = &ValueView_KnownDenom_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnknownDenom", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ValueView_UnknownDenom{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.ValueView = &ValueView_UnknownDenom_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAsset(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAsset + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValueView_KnownDenom) 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 ErrIntOverflowAsset + } + 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: KnownDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KnownDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Amount == nil { + m.Amount = &v1alpha1.Amount{} + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Denom == nil { + m.Denom = &DenomMetadata{} + } + if err := m.Denom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAsset(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAsset + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValueView_UnknownDenom) 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 ErrIntOverflowAsset + } + 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: UnknownDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnknownDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Amount == nil { + m.Amount = &v1alpha1.Amount{} + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAsset + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAsset + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAsset + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AssetId == nil { + m.AssetId = &AssetId{} + } + if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAsset(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAsset + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipAsset(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, ErrIntOverflowAsset + } + 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, ErrIntOverflowAsset + } + 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, ErrIntOverflowAsset + } + 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, ErrInvalidLengthAsset + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupAsset + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthAsset + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthAsset = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowAsset = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupAsset = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/chain/v1alpha1/chain.pb.go b/relayer/chains/penumbra/core/chain/v1alpha1/chain.pb.go deleted file mode 100644 index 16e8fe13e..000000000 --- a/relayer/chains/penumbra/core/chain/v1alpha1/chain.pb.go +++ /dev/null @@ -1,4551 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: penumbra/core/chain/v1alpha1/chain.proto - -package chainv1alpha1 - -import ( - fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" - v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" - v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/dex/v1alpha1" - v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/stake/v1alpha1" - 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 - -// Global chain configuration data, such as chain ID, epoch duration, etc. -type ChainParameters struct { - // The identifier of the chain. - ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` - // The duration of each epoch, in number of blocks. - EpochDuration uint64 `protobuf:"varint,2,opt,name=epoch_duration,json=epochDuration,proto3" json:"epoch_duration,omitempty"` - // The number of epochs an unbonding note for before being released. - UnbondingEpochs uint64 `protobuf:"varint,3,opt,name=unbonding_epochs,json=unbondingEpochs,proto3" json:"unbonding_epochs,omitempty"` - // The maximum number of validators in the consensus set. - ActiveValidatorLimit uint64 `protobuf:"varint,4,opt,name=active_validator_limit,json=activeValidatorLimit,proto3" json:"active_validator_limit,omitempty"` - // The base reward rate, expressed in basis points of basis points - BaseRewardRate uint64 `protobuf:"varint,9,opt,name=base_reward_rate,json=baseRewardRate,proto3" json:"base_reward_rate,omitempty"` - // The penalty for slashing due to misbehavior. - SlashingPenaltyMisbehavior uint64 `protobuf:"varint,5,opt,name=slashing_penalty_misbehavior,json=slashingPenaltyMisbehavior,proto3" json:"slashing_penalty_misbehavior,omitempty"` - // The penalty for slashing due to downtime. - SlashingPenaltyDowntime uint64 `protobuf:"varint,10,opt,name=slashing_penalty_downtime,json=slashingPenaltyDowntime,proto3" json:"slashing_penalty_downtime,omitempty"` - // The number of blocks in the window to check for downtime. - SignedBlocksWindowLen uint64 `protobuf:"varint,11,opt,name=signed_blocks_window_len,json=signedBlocksWindowLen,proto3" json:"signed_blocks_window_len,omitempty"` - // The maximum number of blocks in the window each validator can miss signing without slashing. - MissedBlocksMaximum uint64 `protobuf:"varint,12,opt,name=missed_blocks_maximum,json=missedBlocksMaximum,proto3" json:"missed_blocks_maximum,omitempty"` - // Whether IBC (forming connections, processing IBC packets) is enabled. - IbcEnabled bool `protobuf:"varint,6,opt,name=ibc_enabled,json=ibcEnabled,proto3" json:"ibc_enabled,omitempty"` - // Whether inbound ICS-20 transfers are enabled - InboundIcs20TransfersEnabled bool `protobuf:"varint,7,opt,name=inbound_ics20_transfers_enabled,json=inboundIcs20TransfersEnabled,proto3" json:"inbound_ics20_transfers_enabled,omitempty"` - // Whether outbound ICS-20 transfers are enabled - OutboundIcs20TransfersEnabled bool `protobuf:"varint,8,opt,name=outbound_ics20_transfers_enabled,json=outboundIcs20TransfersEnabled,proto3" json:"outbound_ics20_transfers_enabled,omitempty"` - // The number of blocks during which a proposal is voted on. - ProposalVotingBlocks uint64 `protobuf:"varint,20,opt,name=proposal_voting_blocks,json=proposalVotingBlocks,proto3" json:"proposal_voting_blocks,omitempty"` - // The deposit required to create a proposal. - ProposalDepositAmount *v1alpha1.Amount `protobuf:"bytes,21,opt,name=proposal_deposit_amount,json=proposalDepositAmount,proto3" json:"proposal_deposit_amount,omitempty"` - // The quorum required for a proposal to be considered valid, as a fraction of the total stake - // weight of the network. - ProposalValidQuorum string `protobuf:"bytes,22,opt,name=proposal_valid_quorum,json=proposalValidQuorum,proto3" json:"proposal_valid_quorum,omitempty"` - // The threshold for a proposal to pass voting, as a ratio of "yes" votes over "no" votes. - ProposalPassThreshold string `protobuf:"bytes,23,opt,name=proposal_pass_threshold,json=proposalPassThreshold,proto3" json:"proposal_pass_threshold,omitempty"` - // The threshold for a proposal to be slashed, regardless of whether the "yes" and "no" votes - // would have passed it, as a ratio of "no" votes over all total votes. - ProposalSlashThreshold string `protobuf:"bytes,24,opt,name=proposal_slash_threshold,json=proposalSlashThreshold,proto3" json:"proposal_slash_threshold,omitempty"` - // Whether DAO spend proposals are enabled. - DaoSpendProposalsEnabled bool `protobuf:"varint,25,opt,name=dao_spend_proposals_enabled,json=daoSpendProposalsEnabled,proto3" json:"dao_spend_proposals_enabled,omitempty"` -} - -func (m *ChainParameters) Reset() { *m = ChainParameters{} } -func (m *ChainParameters) String() string { return proto.CompactTextString(m) } -func (*ChainParameters) ProtoMessage() {} -func (*ChainParameters) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{0} -} -func (m *ChainParameters) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ChainParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ChainParameters.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 *ChainParameters) XXX_Merge(src proto.Message) { - xxx_messageInfo_ChainParameters.Merge(m, src) -} -func (m *ChainParameters) XXX_Size() int { - return m.Size() -} -func (m *ChainParameters) XXX_DiscardUnknown() { - xxx_messageInfo_ChainParameters.DiscardUnknown(m) -} - -var xxx_messageInfo_ChainParameters proto.InternalMessageInfo - -func (m *ChainParameters) GetChainId() string { - if m != nil { - return m.ChainId - } - return "" -} - -func (m *ChainParameters) GetEpochDuration() uint64 { - if m != nil { - return m.EpochDuration - } - return 0 -} - -func (m *ChainParameters) GetUnbondingEpochs() uint64 { - if m != nil { - return m.UnbondingEpochs - } - return 0 -} - -func (m *ChainParameters) GetActiveValidatorLimit() uint64 { - if m != nil { - return m.ActiveValidatorLimit - } - return 0 -} - -func (m *ChainParameters) GetBaseRewardRate() uint64 { - if m != nil { - return m.BaseRewardRate - } - return 0 -} - -func (m *ChainParameters) GetSlashingPenaltyMisbehavior() uint64 { - if m != nil { - return m.SlashingPenaltyMisbehavior - } - return 0 -} - -func (m *ChainParameters) GetSlashingPenaltyDowntime() uint64 { - if m != nil { - return m.SlashingPenaltyDowntime - } - return 0 -} - -func (m *ChainParameters) GetSignedBlocksWindowLen() uint64 { - if m != nil { - return m.SignedBlocksWindowLen - } - return 0 -} - -func (m *ChainParameters) GetMissedBlocksMaximum() uint64 { - if m != nil { - return m.MissedBlocksMaximum - } - return 0 -} - -func (m *ChainParameters) GetIbcEnabled() bool { - if m != nil { - return m.IbcEnabled - } - return false -} - -func (m *ChainParameters) GetInboundIcs20TransfersEnabled() bool { - if m != nil { - return m.InboundIcs20TransfersEnabled - } - return false -} - -func (m *ChainParameters) GetOutboundIcs20TransfersEnabled() bool { - if m != nil { - return m.OutboundIcs20TransfersEnabled - } - return false -} - -func (m *ChainParameters) GetProposalVotingBlocks() uint64 { - if m != nil { - return m.ProposalVotingBlocks - } - return 0 -} - -func (m *ChainParameters) GetProposalDepositAmount() *v1alpha1.Amount { - if m != nil { - return m.ProposalDepositAmount - } - return nil -} - -func (m *ChainParameters) GetProposalValidQuorum() string { - if m != nil { - return m.ProposalValidQuorum - } - return "" -} - -func (m *ChainParameters) GetProposalPassThreshold() string { - if m != nil { - return m.ProposalPassThreshold - } - return "" -} - -func (m *ChainParameters) GetProposalSlashThreshold() string { - if m != nil { - return m.ProposalSlashThreshold - } - return "" -} - -func (m *ChainParameters) GetDaoSpendProposalsEnabled() bool { - if m != nil { - return m.DaoSpendProposalsEnabled - } - return false -} - -// The ratio between two numbers, used in governance to describe vote thresholds and quorums. -type Ratio struct { - // The numerator. - Numerator uint64 `protobuf:"varint,1,opt,name=numerator,proto3" json:"numerator,omitempty"` - // The denominator. - Denominator uint64 `protobuf:"varint,2,opt,name=denominator,proto3" json:"denominator,omitempty"` -} - -func (m *Ratio) Reset() { *m = Ratio{} } -func (m *Ratio) String() string { return proto.CompactTextString(m) } -func (*Ratio) ProtoMessage() {} -func (*Ratio) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{1} -} -func (m *Ratio) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Ratio) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Ratio.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 *Ratio) XXX_Merge(src proto.Message) { - xxx_messageInfo_Ratio.Merge(m, src) -} -func (m *Ratio) XXX_Size() int { - return m.Size() -} -func (m *Ratio) XXX_DiscardUnknown() { - xxx_messageInfo_Ratio.DiscardUnknown(m) -} - -var xxx_messageInfo_Ratio proto.InternalMessageInfo - -func (m *Ratio) GetNumerator() uint64 { - if m != nil { - return m.Numerator - } - return 0 -} - -func (m *Ratio) GetDenominator() uint64 { - if m != nil { - return m.Denominator - } - return 0 -} - -// Parameters for Fuzzy Message Detection -type FmdParameters struct { - PrecisionBits uint32 `protobuf:"varint,1,opt,name=precision_bits,json=precisionBits,proto3" json:"precision_bits,omitempty"` - AsOfBlockHeight uint64 `protobuf:"varint,2,opt,name=as_of_block_height,json=asOfBlockHeight,proto3" json:"as_of_block_height,omitempty"` -} - -func (m *FmdParameters) Reset() { *m = FmdParameters{} } -func (m *FmdParameters) String() string { return proto.CompactTextString(m) } -func (*FmdParameters) ProtoMessage() {} -func (*FmdParameters) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{2} -} -func (m *FmdParameters) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *FmdParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_FmdParameters.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 *FmdParameters) XXX_Merge(src proto.Message) { - xxx_messageInfo_FmdParameters.Merge(m, src) -} -func (m *FmdParameters) XXX_Size() int { - return m.Size() -} -func (m *FmdParameters) XXX_DiscardUnknown() { - xxx_messageInfo_FmdParameters.DiscardUnknown(m) -} - -var xxx_messageInfo_FmdParameters proto.InternalMessageInfo - -func (m *FmdParameters) GetPrecisionBits() uint32 { - if m != nil { - return m.PrecisionBits - } - return 0 -} - -func (m *FmdParameters) GetAsOfBlockHeight() uint64 { - if m != nil { - return m.AsOfBlockHeight - } - return 0 -} - -// Contains the minimum data needed to update client state. -type CompactBlock struct { - Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` - // State payloads describing new state fragments. - StatePayloads []*StatePayload `protobuf:"bytes,2,rep,name=state_payloads,json=statePayloads,proto3" json:"state_payloads,omitempty"` - // Nullifiers identifying spent notes. - Nullifiers []*v1alpha1.Nullifier `protobuf:"bytes,3,rep,name=nullifiers,proto3" json:"nullifiers,omitempty"` - // The block root of this block. - BlockRoot *v1alpha1.MerkleRoot `protobuf:"bytes,4,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty"` - // The epoch root of this epoch (only present when the block is the last in an epoch). - EpochRoot *v1alpha1.MerkleRoot `protobuf:"bytes,17,opt,name=epoch_root,json=epochRoot,proto3" json:"epoch_root,omitempty"` - // If a proposal started voting in this block, this is set to `true`. - ProposalStarted bool `protobuf:"varint,20,opt,name=proposal_started,json=proposalStarted,proto3" json:"proposal_started,omitempty"` - // Latest Fuzzy Message Detection parameters. - FmdParameters *FmdParameters `protobuf:"bytes,100,opt,name=fmd_parameters,json=fmdParameters,proto3" json:"fmd_parameters,omitempty"` - // Price data for swaps executed in this block. - SwapOutputs []*v1alpha11.BatchSwapOutputData `protobuf:"bytes,5,rep,name=swap_outputs,json=swapOutputs,proto3" json:"swap_outputs,omitempty"` - // Updated chain parameters, if they have changed. - ChainParameters *ChainParameters `protobuf:"bytes,6,opt,name=chain_parameters,json=chainParameters,proto3" json:"chain_parameters,omitempty"` -} - -func (m *CompactBlock) Reset() { *m = CompactBlock{} } -func (m *CompactBlock) String() string { return proto.CompactTextString(m) } -func (*CompactBlock) ProtoMessage() {} -func (*CompactBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{3} -} -func (m *CompactBlock) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *CompactBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_CompactBlock.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 *CompactBlock) XXX_Merge(src proto.Message) { - xxx_messageInfo_CompactBlock.Merge(m, src) -} -func (m *CompactBlock) XXX_Size() int { - return m.Size() -} -func (m *CompactBlock) XXX_DiscardUnknown() { - xxx_messageInfo_CompactBlock.DiscardUnknown(m) -} - -var xxx_messageInfo_CompactBlock proto.InternalMessageInfo - -func (m *CompactBlock) GetHeight() uint64 { - if m != nil { - return m.Height - } - return 0 -} - -func (m *CompactBlock) GetStatePayloads() []*StatePayload { - if m != nil { - return m.StatePayloads - } - return nil -} - -func (m *CompactBlock) GetNullifiers() []*v1alpha1.Nullifier { - if m != nil { - return m.Nullifiers - } - return nil -} - -func (m *CompactBlock) GetBlockRoot() *v1alpha1.MerkleRoot { - if m != nil { - return m.BlockRoot - } - return nil -} - -func (m *CompactBlock) GetEpochRoot() *v1alpha1.MerkleRoot { - if m != nil { - return m.EpochRoot - } - return nil -} - -func (m *CompactBlock) GetProposalStarted() bool { - if m != nil { - return m.ProposalStarted - } - return false -} - -func (m *CompactBlock) GetFmdParameters() *FmdParameters { - if m != nil { - return m.FmdParameters - } - return nil -} - -func (m *CompactBlock) GetSwapOutputs() []*v1alpha11.BatchSwapOutputData { - if m != nil { - return m.SwapOutputs - } - return nil -} - -func (m *CompactBlock) GetChainParameters() *ChainParameters { - if m != nil { - return m.ChainParameters - } - return nil -} - -type StatePayload struct { - // Types that are valid to be assigned to StatePayload: - // *StatePayload_RolledUp_ - // *StatePayload_Note_ - // *StatePayload_Swap_ - StatePayload isStatePayload_StatePayload `protobuf_oneof:"state_payload"` -} - -func (m *StatePayload) Reset() { *m = StatePayload{} } -func (m *StatePayload) String() string { return proto.CompactTextString(m) } -func (*StatePayload) ProtoMessage() {} -func (*StatePayload) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{4} -} -func (m *StatePayload) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StatePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StatePayload.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 *StatePayload) XXX_Merge(src proto.Message) { - xxx_messageInfo_StatePayload.Merge(m, src) -} -func (m *StatePayload) XXX_Size() int { - return m.Size() -} -func (m *StatePayload) XXX_DiscardUnknown() { - xxx_messageInfo_StatePayload.DiscardUnknown(m) -} - -var xxx_messageInfo_StatePayload proto.InternalMessageInfo - -type isStatePayload_StatePayload interface { - isStatePayload_StatePayload() - MarshalTo([]byte) (int, error) - Size() int -} - -type StatePayload_RolledUp_ struct { - RolledUp *StatePayload_RolledUp `protobuf:"bytes,1,opt,name=rolled_up,json=rolledUp,proto3,oneof" json:"rolled_up,omitempty"` -} -type StatePayload_Note_ struct { - Note *StatePayload_Note `protobuf:"bytes,2,opt,name=note,proto3,oneof" json:"note,omitempty"` -} -type StatePayload_Swap_ struct { - Swap *StatePayload_Swap `protobuf:"bytes,3,opt,name=swap,proto3,oneof" json:"swap,omitempty"` -} - -func (*StatePayload_RolledUp_) isStatePayload_StatePayload() {} -func (*StatePayload_Note_) isStatePayload_StatePayload() {} -func (*StatePayload_Swap_) isStatePayload_StatePayload() {} - -func (m *StatePayload) GetStatePayload() isStatePayload_StatePayload { - if m != nil { - return m.StatePayload - } - return nil -} - -func (m *StatePayload) GetRolledUp() *StatePayload_RolledUp { - if x, ok := m.GetStatePayload().(*StatePayload_RolledUp_); ok { - return x.RolledUp - } - return nil -} - -func (m *StatePayload) GetNote() *StatePayload_Note { - if x, ok := m.GetStatePayload().(*StatePayload_Note_); ok { - return x.Note - } - return nil -} - -func (m *StatePayload) GetSwap() *StatePayload_Swap { - if x, ok := m.GetStatePayload().(*StatePayload_Swap_); ok { - return x.Swap - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*StatePayload) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*StatePayload_RolledUp_)(nil), - (*StatePayload_Note_)(nil), - (*StatePayload_Swap_)(nil), - } -} - -type StatePayload_RolledUp struct { - Commitment *v1alpha1.StateCommitment `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"` -} - -func (m *StatePayload_RolledUp) Reset() { *m = StatePayload_RolledUp{} } -func (m *StatePayload_RolledUp) String() string { return proto.CompactTextString(m) } -func (*StatePayload_RolledUp) ProtoMessage() {} -func (*StatePayload_RolledUp) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{4, 0} -} -func (m *StatePayload_RolledUp) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StatePayload_RolledUp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StatePayload_RolledUp.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 *StatePayload_RolledUp) XXX_Merge(src proto.Message) { - xxx_messageInfo_StatePayload_RolledUp.Merge(m, src) -} -func (m *StatePayload_RolledUp) XXX_Size() int { - return m.Size() -} -func (m *StatePayload_RolledUp) XXX_DiscardUnknown() { - xxx_messageInfo_StatePayload_RolledUp.DiscardUnknown(m) -} - -var xxx_messageInfo_StatePayload_RolledUp proto.InternalMessageInfo - -func (m *StatePayload_RolledUp) GetCommitment() *v1alpha1.StateCommitment { - if m != nil { - return m.Commitment - } - return nil -} - -type StatePayload_Note struct { - Source *NoteSource `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"` - Note *v1alpha1.NotePayload `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` -} - -func (m *StatePayload_Note) Reset() { *m = StatePayload_Note{} } -func (m *StatePayload_Note) String() string { return proto.CompactTextString(m) } -func (*StatePayload_Note) ProtoMessage() {} -func (*StatePayload_Note) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{4, 1} -} -func (m *StatePayload_Note) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StatePayload_Note) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StatePayload_Note.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 *StatePayload_Note) XXX_Merge(src proto.Message) { - xxx_messageInfo_StatePayload_Note.Merge(m, src) -} -func (m *StatePayload_Note) XXX_Size() int { - return m.Size() -} -func (m *StatePayload_Note) XXX_DiscardUnknown() { - xxx_messageInfo_StatePayload_Note.DiscardUnknown(m) -} - -var xxx_messageInfo_StatePayload_Note proto.InternalMessageInfo - -func (m *StatePayload_Note) GetSource() *NoteSource { - if m != nil { - return m.Source - } - return nil -} - -func (m *StatePayload_Note) GetNote() *v1alpha1.NotePayload { - if m != nil { - return m.Note - } - return nil -} - -type StatePayload_Swap struct { - Source *NoteSource `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"` - Swap *v1alpha11.SwapPayload `protobuf:"bytes,2,opt,name=swap,proto3" json:"swap,omitempty"` -} - -func (m *StatePayload_Swap) Reset() { *m = StatePayload_Swap{} } -func (m *StatePayload_Swap) String() string { return proto.CompactTextString(m) } -func (*StatePayload_Swap) ProtoMessage() {} -func (*StatePayload_Swap) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{4, 2} -} -func (m *StatePayload_Swap) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StatePayload_Swap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StatePayload_Swap.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 *StatePayload_Swap) XXX_Merge(src proto.Message) { - xxx_messageInfo_StatePayload_Swap.Merge(m, src) -} -func (m *StatePayload_Swap) XXX_Size() int { - return m.Size() -} -func (m *StatePayload_Swap) XXX_DiscardUnknown() { - xxx_messageInfo_StatePayload_Swap.DiscardUnknown(m) -} - -var xxx_messageInfo_StatePayload_Swap proto.InternalMessageInfo - -func (m *StatePayload_Swap) GetSource() *NoteSource { - if m != nil { - return m.Source - } - return nil -} - -func (m *StatePayload_Swap) GetSwap() *v1alpha11.SwapPayload { - if m != nil { - return m.Swap - } - return nil -} - -type KnownAssets struct { - Assets []*v1alpha1.DenomMetadata `protobuf:"bytes,1,rep,name=assets,proto3" json:"assets,omitempty"` -} - -func (m *KnownAssets) Reset() { *m = KnownAssets{} } -func (m *KnownAssets) String() string { return proto.CompactTextString(m) } -func (*KnownAssets) ProtoMessage() {} -func (*KnownAssets) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{5} -} -func (m *KnownAssets) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *KnownAssets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_KnownAssets.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 *KnownAssets) XXX_Merge(src proto.Message) { - xxx_messageInfo_KnownAssets.Merge(m, src) -} -func (m *KnownAssets) XXX_Size() int { - return m.Size() -} -func (m *KnownAssets) XXX_DiscardUnknown() { - xxx_messageInfo_KnownAssets.DiscardUnknown(m) -} - -var xxx_messageInfo_KnownAssets proto.InternalMessageInfo - -func (m *KnownAssets) GetAssets() []*v1alpha1.DenomMetadata { - if m != nil { - return m.Assets - } - return nil -} - -// A spicy transaction ID -type NoteSource struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *NoteSource) Reset() { *m = NoteSource{} } -func (m *NoteSource) String() string { return proto.CompactTextString(m) } -func (*NoteSource) ProtoMessage() {} -func (*NoteSource) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{6} -} -func (m *NoteSource) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *NoteSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_NoteSource.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 *NoteSource) XXX_Merge(src proto.Message) { - xxx_messageInfo_NoteSource.Merge(m, src) -} -func (m *NoteSource) XXX_Size() int { - return m.Size() -} -func (m *NoteSource) XXX_DiscardUnknown() { - xxx_messageInfo_NoteSource.DiscardUnknown(m) -} - -var xxx_messageInfo_NoteSource proto.InternalMessageInfo - -func (m *NoteSource) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A NoteSource paired with the height at which the note was spent -type SpendInfo struct { - NoteSource *NoteSource `protobuf:"bytes,1,opt,name=note_source,json=noteSource,proto3" json:"note_source,omitempty"` - SpendHeight uint64 `protobuf:"varint,2,opt,name=spend_height,json=spendHeight,proto3" json:"spend_height,omitempty"` -} - -func (m *SpendInfo) Reset() { *m = SpendInfo{} } -func (m *SpendInfo) String() string { return proto.CompactTextString(m) } -func (*SpendInfo) ProtoMessage() {} -func (*SpendInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{7} -} -func (m *SpendInfo) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SpendInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SpendInfo.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 *SpendInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpendInfo.Merge(m, src) -} -func (m *SpendInfo) XXX_Size() int { - return m.Size() -} -func (m *SpendInfo) XXX_DiscardUnknown() { - xxx_messageInfo_SpendInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_SpendInfo proto.InternalMessageInfo - -func (m *SpendInfo) GetNoteSource() *NoteSource { - if m != nil { - return m.NoteSource - } - return nil -} - -func (m *SpendInfo) GetSpendHeight() uint64 { - if m != nil { - return m.SpendHeight - } - return 0 -} - -type GenesisAppState struct { - ChainParams *ChainParameters `protobuf:"bytes,1,opt,name=chain_params,json=chainParams,proto3" json:"chain_params,omitempty"` - Validators []*v1alpha12.Validator `protobuf:"bytes,2,rep,name=validators,proto3" json:"validators,omitempty"` - Allocations []*GenesisAppState_Allocation `protobuf:"bytes,3,rep,name=allocations,proto3" json:"allocations,omitempty"` -} - -func (m *GenesisAppState) Reset() { *m = GenesisAppState{} } -func (m *GenesisAppState) String() string { return proto.CompactTextString(m) } -func (*GenesisAppState) ProtoMessage() {} -func (*GenesisAppState) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{8} -} -func (m *GenesisAppState) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *GenesisAppState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_GenesisAppState.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 *GenesisAppState) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenesisAppState.Merge(m, src) -} -func (m *GenesisAppState) XXX_Size() int { - return m.Size() -} -func (m *GenesisAppState) XXX_DiscardUnknown() { - xxx_messageInfo_GenesisAppState.DiscardUnknown(m) -} - -var xxx_messageInfo_GenesisAppState proto.InternalMessageInfo - -func (m *GenesisAppState) GetChainParams() *ChainParameters { - if m != nil { - return m.ChainParams - } - return nil -} - -func (m *GenesisAppState) GetValidators() []*v1alpha12.Validator { - if m != nil { - return m.Validators - } - return nil -} - -func (m *GenesisAppState) GetAllocations() []*GenesisAppState_Allocation { - if m != nil { - return m.Allocations - } - return nil -} - -type GenesisAppState_Allocation struct { - Amount *v1alpha1.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` - Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"` - Address *v1alpha1.Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` -} - -func (m *GenesisAppState_Allocation) Reset() { *m = GenesisAppState_Allocation{} } -func (m *GenesisAppState_Allocation) String() string { return proto.CompactTextString(m) } -func (*GenesisAppState_Allocation) ProtoMessage() {} -func (*GenesisAppState_Allocation) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{8, 0} -} -func (m *GenesisAppState_Allocation) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *GenesisAppState_Allocation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_GenesisAppState_Allocation.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 *GenesisAppState_Allocation) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenesisAppState_Allocation.Merge(m, src) -} -func (m *GenesisAppState_Allocation) XXX_Size() int { - return m.Size() -} -func (m *GenesisAppState_Allocation) XXX_DiscardUnknown() { - xxx_messageInfo_GenesisAppState_Allocation.DiscardUnknown(m) -} - -var xxx_messageInfo_GenesisAppState_Allocation proto.InternalMessageInfo - -func (m *GenesisAppState_Allocation) GetAmount() *v1alpha1.Amount { - if m != nil { - return m.Amount - } - return nil -} - -func (m *GenesisAppState_Allocation) GetDenom() string { - if m != nil { - return m.Denom - } - return "" -} - -func (m *GenesisAppState_Allocation) GetAddress() *v1alpha1.Address { - if m != nil { - return m.Address - } - return nil -} - -type Epoch struct { - Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` - StartHeight uint64 `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` -} - -func (m *Epoch) Reset() { *m = Epoch{} } -func (m *Epoch) String() string { return proto.CompactTextString(m) } -func (*Epoch) ProtoMessage() {} -func (*Epoch) Descriptor() ([]byte, []int) { - return fileDescriptor_b0cedb8b84ba3224, []int{9} -} -func (m *Epoch) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Epoch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Epoch.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 *Epoch) XXX_Merge(src proto.Message) { - xxx_messageInfo_Epoch.Merge(m, src) -} -func (m *Epoch) XXX_Size() int { - return m.Size() -} -func (m *Epoch) XXX_DiscardUnknown() { - xxx_messageInfo_Epoch.DiscardUnknown(m) -} - -var xxx_messageInfo_Epoch proto.InternalMessageInfo - -func (m *Epoch) GetIndex() uint64 { - if m != nil { - return m.Index - } - return 0 -} - -func (m *Epoch) GetStartHeight() uint64 { - if m != nil { - return m.StartHeight - } - return 0 -} - -func init() { - proto.RegisterType((*ChainParameters)(nil), "penumbra.core.chain.v1alpha1.ChainParameters") - proto.RegisterType((*Ratio)(nil), "penumbra.core.chain.v1alpha1.Ratio") - proto.RegisterType((*FmdParameters)(nil), "penumbra.core.chain.v1alpha1.FmdParameters") - proto.RegisterType((*CompactBlock)(nil), "penumbra.core.chain.v1alpha1.CompactBlock") - proto.RegisterType((*StatePayload)(nil), "penumbra.core.chain.v1alpha1.StatePayload") - proto.RegisterType((*StatePayload_RolledUp)(nil), "penumbra.core.chain.v1alpha1.StatePayload.RolledUp") - proto.RegisterType((*StatePayload_Note)(nil), "penumbra.core.chain.v1alpha1.StatePayload.Note") - proto.RegisterType((*StatePayload_Swap)(nil), "penumbra.core.chain.v1alpha1.StatePayload.Swap") - proto.RegisterType((*KnownAssets)(nil), "penumbra.core.chain.v1alpha1.KnownAssets") - proto.RegisterType((*NoteSource)(nil), "penumbra.core.chain.v1alpha1.NoteSource") - proto.RegisterType((*SpendInfo)(nil), "penumbra.core.chain.v1alpha1.SpendInfo") - proto.RegisterType((*GenesisAppState)(nil), "penumbra.core.chain.v1alpha1.GenesisAppState") - proto.RegisterType((*GenesisAppState_Allocation)(nil), "penumbra.core.chain.v1alpha1.GenesisAppState.Allocation") - proto.RegisterType((*Epoch)(nil), "penumbra.core.chain.v1alpha1.Epoch") -} - -func init() { - proto.RegisterFile("penumbra/core/chain/v1alpha1/chain.proto", fileDescriptor_b0cedb8b84ba3224) -} - -var fileDescriptor_b0cedb8b84ba3224 = []byte{ - // 1498 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4b, 0x6f, 0x1c, 0xc7, - 0x11, 0xe6, 0xf2, 0xcd, 0x5a, 0xbe, 0xd2, 0x12, 0xa9, 0x11, 0xc3, 0x50, 0x9b, 0x45, 0x94, 0xac, - 0xa4, 0x64, 0x37, 0xa2, 0x84, 0x44, 0xa0, 0xa0, 0x80, 0xcf, 0x90, 0x44, 0x44, 0x69, 0x35, 0x54, - 0x98, 0x40, 0x60, 0x30, 0xe8, 0x9d, 0x69, 0x72, 0x1b, 0x9a, 0xe9, 0x9e, 0x4c, 0xf7, 0xf0, 0x71, - 0x4f, 0x00, 0x1f, 0xfd, 0x1b, 0xec, 0x9b, 0x0f, 0x06, 0xfc, 0x2f, 0x0c, 0x9f, 0x74, 0xf4, 0xd1, - 0xa0, 0x6e, 0x3e, 0xf9, 0xe0, 0x1f, 0x60, 0x74, 0xf5, 0xcc, 0xec, 0x72, 0x65, 0x2c, 0x4d, 0xc3, - 0xb7, 0xe9, 0xaa, 0xef, 0xfb, 0xba, 0xba, 0xba, 0xaa, 0xbb, 0x07, 0x6a, 0x31, 0x13, 0x69, 0xd4, - 0x4a, 0x68, 0xc3, 0x97, 0x09, 0x6b, 0xf8, 0x6d, 0xca, 0x45, 0xe3, 0xe4, 0x21, 0x0d, 0xe3, 0x36, - 0x7d, 0x68, 0x87, 0xf5, 0x38, 0x91, 0x5a, 0x92, 0xc5, 0x1c, 0x59, 0x37, 0xc8, 0xba, 0x75, 0xe5, - 0xc8, 0x85, 0xfb, 0x3d, 0x3a, 0xc9, 0x79, 0xac, 0x65, 0x97, 0x10, 0x8e, 0xad, 0xd2, 0x42, 0xcf, - 0x9c, 0x4a, 0xd3, 0xb7, 0xac, 0x03, 0xc5, 0x61, 0x86, 0xfc, 0xdd, 0x65, 0x64, 0xc0, 0xce, 0x3a, - 0xb8, 0x80, 0x9d, 0x59, 0x54, 0xf5, 0xfb, 0x31, 0x98, 0xd9, 0x30, 0xe1, 0x34, 0x69, 0x42, 0x23, - 0xa6, 0x59, 0xa2, 0xc8, 0x6d, 0x18, 0xc7, 0x08, 0x3d, 0x1e, 0x38, 0xa5, 0x4a, 0xa9, 0x36, 0xe1, - 0x8e, 0xe1, 0x78, 0x37, 0x20, 0x77, 0x61, 0x9a, 0xc5, 0xd2, 0x6f, 0x7b, 0x41, 0x9a, 0x50, 0xcd, - 0xa5, 0x70, 0x06, 0x2b, 0xa5, 0xda, 0xb0, 0x3b, 0x85, 0xd6, 0xcd, 0xcc, 0x48, 0xee, 0xc1, 0x6c, - 0x2a, 0x5a, 0x52, 0x04, 0x5c, 0x1c, 0x7b, 0xe8, 0x52, 0xce, 0x10, 0x02, 0x67, 0x0a, 0xfb, 0x16, - 0x9a, 0xc9, 0x63, 0x98, 0xa7, 0xbe, 0xe6, 0x27, 0xcc, 0x3b, 0xa1, 0x21, 0x0f, 0xa8, 0x96, 0x89, - 0x17, 0xf2, 0x88, 0x6b, 0x67, 0x18, 0x09, 0x37, 0xad, 0xf7, 0x20, 0x77, 0x3e, 0x37, 0x3e, 0x52, - 0x83, 0xd9, 0x16, 0x55, 0xcc, 0x4b, 0xd8, 0x29, 0x4d, 0x02, 0x2f, 0xa1, 0x9a, 0x39, 0x13, 0x88, - 0x9f, 0x36, 0x76, 0x17, 0xcd, 0x2e, 0xd5, 0x8c, 0xac, 0xc2, 0xa2, 0x0a, 0xa9, 0x6a, 0x9b, 0x48, - 0x62, 0x26, 0x68, 0xa8, 0xcf, 0xbd, 0x88, 0xab, 0x16, 0x6b, 0xd3, 0x13, 0x2e, 0x13, 0x67, 0x04, - 0x59, 0x0b, 0x39, 0xa6, 0x69, 0x21, 0x7b, 0x1d, 0x04, 0x59, 0x81, 0xdb, 0x1f, 0x28, 0x04, 0xf2, - 0x54, 0x68, 0x1e, 0x31, 0x07, 0x90, 0x7e, 0xab, 0x87, 0xbe, 0x99, 0xb9, 0xc9, 0x5f, 0xc1, 0x51, - 0xfc, 0x58, 0xb0, 0xc0, 0x6b, 0x85, 0xd2, 0x7f, 0xab, 0xbc, 0x53, 0x2e, 0x02, 0x79, 0xea, 0x85, - 0x4c, 0x38, 0x65, 0xa4, 0xce, 0x59, 0xff, 0x3a, 0xba, 0xff, 0x85, 0xde, 0xe7, 0x4c, 0x90, 0x65, - 0x98, 0x8b, 0xb8, 0x52, 0x1d, 0x62, 0x44, 0xcf, 0x78, 0x94, 0x46, 0xce, 0x24, 0xb2, 0x6e, 0x58, - 0xa7, 0x65, 0xed, 0x59, 0x17, 0xb9, 0x03, 0x65, 0xde, 0xf2, 0x3d, 0x26, 0x68, 0x2b, 0x64, 0x81, - 0x33, 0x5a, 0x29, 0xd5, 0xc6, 0x5d, 0xe0, 0x2d, 0x7f, 0xcb, 0x5a, 0xc8, 0x16, 0xdc, 0xe1, 0xa2, - 0x25, 0x53, 0x11, 0x78, 0xdc, 0x57, 0xcb, 0x7f, 0xf6, 0x74, 0x42, 0x85, 0x3a, 0x62, 0x89, 0x2a, - 0x48, 0x63, 0x48, 0x5a, 0xcc, 0x60, 0xbb, 0x06, 0xf5, 0x3a, 0x07, 0xe5, 0x32, 0xdb, 0x50, 0x91, - 0xa9, 0xee, 0xaf, 0x33, 0x8e, 0x3a, 0xbf, 0xc9, 0x71, 0x3f, 0x2e, 0xf4, 0x18, 0xe6, 0xe3, 0x44, - 0xc6, 0x52, 0xd1, 0xd0, 0x3b, 0x91, 0xda, 0x24, 0xd8, 0xae, 0xd6, 0xb9, 0x69, 0xf7, 0x3e, 0xf7, - 0x1e, 0xa0, 0xd3, 0xae, 0x96, 0xfc, 0x07, 0x6e, 0x15, 0xac, 0x80, 0xc5, 0x52, 0x71, 0xed, 0xd1, - 0x48, 0xa6, 0x42, 0x3b, 0x73, 0x95, 0x52, 0xad, 0xbc, 0x7c, 0xb7, 0xde, 0xd3, 0x6e, 0xb6, 0x81, - 0xf2, 0xea, 0xaf, 0xaf, 0x21, 0xd8, 0x9d, 0xcb, 0x55, 0x36, 0xad, 0x88, 0x35, 0x9b, 0xcc, 0x77, - 0x82, 0x32, 0x55, 0xe7, 0xfd, 0x37, 0x95, 0x49, 0x1a, 0x39, 0xf3, 0xd8, 0x0a, 0x37, 0x8a, 0x98, - 0x8c, 0xef, 0x15, 0xba, 0xc8, 0x5f, 0xba, 0x42, 0x8a, 0xa9, 0x52, 0x9e, 0x6e, 0x27, 0x4c, 0xb5, - 0x65, 0x18, 0x38, 0xb7, 0x90, 0x55, 0x48, 0x36, 0xa9, 0x52, 0xaf, 0x73, 0x27, 0x79, 0x02, 0x4e, - 0xc1, 0xc3, 0x12, 0xea, 0x22, 0x3a, 0x48, 0x2c, 0x12, 0xb4, 0x6f, 0xdc, 0x1d, 0xe6, 0x33, 0xf8, - 0x75, 0x40, 0xa5, 0xa7, 0x62, 0x26, 0x02, 0x2f, 0xc7, 0x74, 0xd2, 0x7f, 0x1b, 0xd3, 0xef, 0x04, - 0x54, 0xee, 0x1b, 0x44, 0x33, 0x07, 0x64, 0x99, 0xaf, 0x6e, 0xc3, 0x88, 0x6b, 0x5a, 0x95, 0x2c, - 0xc2, 0x84, 0x48, 0x23, 0x96, 0x98, 0xd6, 0xc2, 0x66, 0x1f, 0x76, 0x3b, 0x06, 0x52, 0x81, 0x72, - 0xc0, 0x84, 0x8c, 0xb8, 0x40, 0xbf, 0xed, 0xf5, 0x6e, 0x53, 0xd5, 0x87, 0xa9, 0xbf, 0x47, 0x41, - 0xd7, 0xe1, 0x71, 0x17, 0xa6, 0xe3, 0x84, 0xf9, 0x5c, 0x71, 0x29, 0xbc, 0x16, 0xd7, 0x0a, 0x55, - 0xa7, 0xdc, 0xa9, 0xc2, 0xba, 0xce, 0xb5, 0x22, 0x0f, 0x80, 0x50, 0xe5, 0xc9, 0x23, 0xbb, 0xe1, - 0x5e, 0x9b, 0xf1, 0xe3, 0xb6, 0xce, 0x26, 0x98, 0xa1, 0xea, 0xe5, 0x11, 0x6e, 0xf6, 0x0e, 0x9a, - 0xab, 0xff, 0x1b, 0x81, 0xc9, 0x0d, 0x19, 0xc5, 0xd4, 0xd7, 0x68, 0x26, 0xf3, 0x30, 0x9a, 0x31, - 0x6c, 0xc8, 0xd9, 0x88, 0xbc, 0x82, 0x69, 0xa5, 0xa9, 0x66, 0x5e, 0x4c, 0xcf, 0x43, 0x49, 0x03, - 0xe5, 0x0c, 0x56, 0x86, 0x6a, 0xe5, 0xe5, 0xfb, 0xf5, 0x7e, 0x07, 0x70, 0x7d, 0xdf, 0x70, 0x9a, - 0x96, 0xe2, 0x4e, 0xa9, 0xae, 0x91, 0x22, 0x3b, 0x00, 0x22, 0x0d, 0x43, 0x7e, 0xc4, 0x59, 0x62, - 0x0e, 0x31, 0x23, 0x57, 0xbb, 0xa2, 0xc0, 0x5e, 0xe4, 0x04, 0xb7, 0x8b, 0x6b, 0x94, 0xec, 0x62, - 0x13, 0x29, 0xed, 0xe9, 0x56, 0x5e, 0xbe, 0x77, 0x85, 0xd2, 0x1e, 0x4b, 0xde, 0x86, 0xcc, 0x95, - 0x52, 0xbb, 0x13, 0x48, 0x36, 0x9f, 0x46, 0xc9, 0x9e, 0xc2, 0xa8, 0xf4, 0xab, 0x6b, 0x2b, 0x21, - 0x19, 0x95, 0xee, 0xc1, 0x6c, 0xa7, 0x00, 0x35, 0x4d, 0x34, 0x0b, 0xb0, 0xf7, 0xc6, 0xdd, 0x99, - 0xa2, 0xf0, 0xac, 0x99, 0xb8, 0x30, 0x7d, 0x14, 0x05, 0x5e, 0x5c, 0x6c, 0xb5, 0x13, 0xe0, 0xc4, - 0x0f, 0xfa, 0xe7, 0xf6, 0x52, 0x75, 0xb8, 0x53, 0x47, 0x97, 0x8a, 0xc5, 0x85, 0x49, 0x75, 0x4a, - 0x63, 0x4f, 0xa6, 0x3a, 0x4e, 0xb5, 0x72, 0x46, 0x30, 0xbd, 0x8d, 0x1e, 0x45, 0x73, 0x5b, 0x15, - 0x7a, 0xeb, 0x54, 0xfb, 0xed, 0xfd, 0x53, 0x1a, 0xbf, 0x44, 0xce, 0x26, 0xd5, 0xd4, 0x2d, 0xab, - 0x62, 0xac, 0xc8, 0xbf, 0x61, 0xd6, 0xde, 0x5e, 0x5d, 0x91, 0x8e, 0x62, 0xa4, 0x7f, 0xea, 0x1f, - 0x69, 0xcf, 0x35, 0xe8, 0xce, 0xf8, 0x97, 0x0d, 0xd5, 0xef, 0x86, 0x61, 0xb2, 0xbb, 0x54, 0x88, - 0x0b, 0x13, 0x89, 0x0c, 0x43, 0x16, 0x78, 0x69, 0x8c, 0x95, 0x58, 0x5e, 0x7e, 0xf4, 0xd3, 0x2b, - 0xad, 0xee, 0x22, 0xf7, 0x9f, 0xf1, 0xce, 0x80, 0x3b, 0x9e, 0x64, 0xdf, 0x64, 0x0b, 0x86, 0x85, - 0xd4, 0x0c, 0x5b, 0xe1, 0xc3, 0x54, 0xf4, 0x93, 0x7b, 0x21, 0x35, 0xdb, 0x19, 0x70, 0x91, 0x6e, - 0x64, 0x4c, 0x52, 0xf0, 0xd6, 0xbd, 0x9e, 0x8c, 0xc9, 0xad, 0x91, 0x31, 0xf4, 0x85, 0x37, 0x30, - 0x9e, 0x47, 0x49, 0x5e, 0x00, 0xf8, 0x32, 0x8a, 0xb8, 0x8e, 0x98, 0xd0, 0xd9, 0x72, 0xeb, 0x57, - 0x54, 0x1d, 0x2a, 0x6f, 0x14, 0x2c, 0xb7, 0x4b, 0x61, 0xe1, 0xa3, 0x12, 0x0c, 0x9b, 0x98, 0xc9, - 0x2a, 0x8c, 0x2a, 0x99, 0x26, 0x3e, 0xcb, 0x44, 0x6b, 0xfd, 0xa3, 0x35, 0x9c, 0x7d, 0xc4, 0xbb, - 0x19, 0x8f, 0xfc, 0xed, 0x52, 0xd2, 0xee, 0x5f, 0xd5, 0x9e, 0xb2, 0xd3, 0xed, 0xc8, 0x5b, 0xf8, - 0x7f, 0x09, 0x86, 0xcd, 0xba, 0x7f, 0x81, 0x50, 0x9e, 0x66, 0x89, 0xb7, 0xa1, 0xfc, 0xa1, 0x5f, - 0x29, 0x9b, 0x19, 0x8b, 0x38, 0x0c, 0x69, 0x7d, 0x06, 0xa6, 0x2e, 0x9d, 0x5f, 0xd5, 0x7d, 0x28, - 0xff, 0x43, 0xc8, 0x53, 0xb1, 0xa6, 0x14, 0xd3, 0x8a, 0x6c, 0xc2, 0x28, 0xc5, 0x2f, 0xa7, 0x84, - 0x9d, 0xf2, 0xc7, 0x2b, 0x56, 0xba, 0x69, 0x4e, 0xea, 0x3d, 0xa6, 0x69, 0x60, 0xda, 0x24, 0xe3, - 0x56, 0xab, 0x00, 0x9d, 0xc0, 0xc9, 0x4d, 0x18, 0xe1, 0x42, 0x30, 0x7b, 0xfa, 0x4f, 0xba, 0x76, - 0x50, 0x3d, 0x87, 0x09, 0xbc, 0x39, 0x76, 0xc5, 0x91, 0x24, 0xbb, 0x50, 0x36, 0x69, 0xf2, 0x7e, - 0x66, 0x6a, 0x40, 0x74, 0x66, 0xfb, 0x2d, 0x4c, 0xda, 0x3b, 0xeb, 0xd2, 0x89, 0x5f, 0x46, 0x5b, - 0x76, 0xda, 0x7f, 0x3e, 0x04, 0x33, 0xdb, 0x4c, 0x30, 0xc5, 0xd5, 0x5a, 0x1c, 0x63, 0x05, 0x91, - 0x26, 0x4c, 0x76, 0x35, 0xb5, 0xca, 0x42, 0xb8, 0x66, 0x43, 0x97, 0x3b, 0x0d, 0xad, 0xc8, 0x36, - 0x40, 0xf1, 0xe0, 0xcc, 0xaf, 0x89, 0xde, 0xdd, 0xb2, 0xcf, 0xe9, 0x42, 0xaf, 0x78, 0x83, 0xba, - 0x5d, 0x54, 0xf2, 0x06, 0xca, 0x34, 0x0c, 0xa5, 0x8f, 0x2f, 0xdf, 0xfc, 0x86, 0x78, 0xd2, 0x3f, - 0xb2, 0x9e, 0xe5, 0xd5, 0xd7, 0x0a, 0x01, 0xb7, 0x5b, 0x6c, 0xe1, 0xd3, 0x12, 0x40, 0xc7, 0x47, - 0x9e, 0xc1, 0x68, 0xf6, 0xd0, 0x29, 0x5d, 0xe7, 0xa1, 0x93, 0x91, 0xcc, 0x4e, 0xe3, 0xd5, 0x8d, - 0x49, 0x9f, 0x70, 0xed, 0x80, 0xac, 0xc2, 0x18, 0x0d, 0x82, 0x84, 0x29, 0x95, 0x1d, 0x16, 0xbf, - 0xbf, 0x4a, 0xd5, 0xa2, 0xdd, 0x9c, 0x56, 0x5d, 0x85, 0x11, 0x7c, 0xcc, 0xdb, 0x52, 0x0a, 0xd8, - 0x59, 0x76, 0x2b, 0xdb, 0x01, 0x6e, 0xb9, 0xb9, 0x43, 0x7a, 0xb7, 0xdc, 0xd8, 0xec, 0x96, 0xaf, - 0x7f, 0x31, 0xf8, 0xe5, 0xc5, 0x52, 0xe9, 0xdd, 0xc5, 0x52, 0xe9, 0x9b, 0x8b, 0xa5, 0xd2, 0xc7, - 0xef, 0x97, 0x06, 0xde, 0xbd, 0x5f, 0x1a, 0xf8, 0xfa, 0xfd, 0xd2, 0x00, 0x54, 0x7c, 0x19, 0xf5, - 0x4d, 0xe6, 0x3a, 0xd8, 0x7d, 0x36, 0xbf, 0x33, 0xcd, 0xd2, 0x9b, 0x83, 0x63, 0xae, 0xdb, 0x69, - 0xab, 0xee, 0xcb, 0xa8, 0xe1, 0x4b, 0x15, 0x49, 0xd5, 0x48, 0x58, 0x48, 0xcf, 0x59, 0xd2, 0x38, - 0x59, 0x2e, 0x3e, 0x51, 0x42, 0x35, 0xfa, 0xfd, 0xc0, 0x3d, 0xc5, 0x61, 0x3e, 0xfa, 0x64, 0x70, - 0xa8, 0xb9, 0xb1, 0xf1, 0xd9, 0xe0, 0x62, 0x33, 0x0f, 0x65, 0xc3, 0x84, 0x82, 0x53, 0xd7, 0x0f, - 0x32, 0xd0, 0x57, 0x1d, 0xf7, 0xa1, 0x71, 0x1f, 0xa2, 0xfb, 0x30, 0x77, 0x5f, 0x0c, 0xd6, 0xfa, - 0xb9, 0x0f, 0xb7, 0x9b, 0xeb, 0x79, 0xaf, 0x7e, 0x3b, 0x78, 0x27, 0x87, 0xae, 0xac, 0x18, 0xec, - 0xca, 0x0a, 0x82, 0x57, 0x56, 0x72, 0x74, 0x6b, 0x14, 0x7f, 0xe0, 0x1e, 0xfd, 0x10, 0x00, 0x00, - 0xff, 0xff, 0xd1, 0xb8, 0x41, 0x47, 0x86, 0x0e, 0x00, 0x00, -} - -func (m *ChainParameters) 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 *ChainParameters) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ChainParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.DaoSpendProposalsEnabled { - i-- - if m.DaoSpendProposalsEnabled { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xc8 - } - if len(m.ProposalSlashThreshold) > 0 { - i -= len(m.ProposalSlashThreshold) - copy(dAtA[i:], m.ProposalSlashThreshold) - i = encodeVarintChain(dAtA, i, uint64(len(m.ProposalSlashThreshold))) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xc2 - } - if len(m.ProposalPassThreshold) > 0 { - i -= len(m.ProposalPassThreshold) - copy(dAtA[i:], m.ProposalPassThreshold) - i = encodeVarintChain(dAtA, i, uint64(len(m.ProposalPassThreshold))) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xba - } - if len(m.ProposalValidQuorum) > 0 { - i -= len(m.ProposalValidQuorum) - copy(dAtA[i:], m.ProposalValidQuorum) - i = encodeVarintChain(dAtA, i, uint64(len(m.ProposalValidQuorum))) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xb2 - } - if m.ProposalDepositAmount != nil { - { - size, err := m.ProposalDepositAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xaa - } - if m.ProposalVotingBlocks != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.ProposalVotingBlocks)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa0 - } - if m.MissedBlocksMaximum != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.MissedBlocksMaximum)) - i-- - dAtA[i] = 0x60 - } - if m.SignedBlocksWindowLen != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.SignedBlocksWindowLen)) - i-- - dAtA[i] = 0x58 - } - if m.SlashingPenaltyDowntime != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.SlashingPenaltyDowntime)) - i-- - dAtA[i] = 0x50 - } - if m.BaseRewardRate != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.BaseRewardRate)) - i-- - dAtA[i] = 0x48 - } - if m.OutboundIcs20TransfersEnabled { - i-- - if m.OutboundIcs20TransfersEnabled { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x40 - } - if m.InboundIcs20TransfersEnabled { - i-- - if m.InboundIcs20TransfersEnabled { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x38 - } - if m.IbcEnabled { - i-- - if m.IbcEnabled { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x30 - } - if m.SlashingPenaltyMisbehavior != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.SlashingPenaltyMisbehavior)) - i-- - dAtA[i] = 0x28 - } - if m.ActiveValidatorLimit != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.ActiveValidatorLimit)) - i-- - dAtA[i] = 0x20 - } - if m.UnbondingEpochs != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.UnbondingEpochs)) - i-- - dAtA[i] = 0x18 - } - if m.EpochDuration != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.EpochDuration)) - i-- - dAtA[i] = 0x10 - } - if len(m.ChainId) > 0 { - i -= len(m.ChainId) - copy(dAtA[i:], m.ChainId) - i = encodeVarintChain(dAtA, i, uint64(len(m.ChainId))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Ratio) 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 *Ratio) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Ratio) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Denominator != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.Denominator)) - i-- - dAtA[i] = 0x10 - } - if m.Numerator != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.Numerator)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *FmdParameters) 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 *FmdParameters) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *FmdParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.AsOfBlockHeight != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.AsOfBlockHeight)) - i-- - dAtA[i] = 0x10 - } - if m.PrecisionBits != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.PrecisionBits)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *CompactBlock) 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 *CompactBlock) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *CompactBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.FmdParameters != nil { - { - size, err := m.FmdParameters.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x6 - i-- - dAtA[i] = 0xa2 - } - if m.ProposalStarted { - i-- - if m.ProposalStarted { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa0 - } - if m.EpochRoot != nil { - { - size, err := m.EpochRoot.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x8a - } - if m.ChainParameters != nil { - { - size, err := m.ChainParameters.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - if len(m.SwapOutputs) > 0 { - for iNdEx := len(m.SwapOutputs) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.SwapOutputs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - } - if m.BlockRoot != nil { - { - size, err := m.BlockRoot.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if len(m.Nullifiers) > 0 { - for iNdEx := len(m.Nullifiers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Nullifiers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - } - if len(m.StatePayloads) > 0 { - for iNdEx := len(m.StatePayloads) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.StatePayloads[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if m.Height != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.Height)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *StatePayload) 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 *StatePayload) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatePayload) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.StatePayload != nil { - { - size := m.StatePayload.Size() - i -= size - if _, err := m.StatePayload.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *StatePayload_RolledUp_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatePayload_RolledUp_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.RolledUp != nil { - { - size, err := m.RolledUp.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *StatePayload_Note_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatePayload_Note_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Note != nil { - { - size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *StatePayload_Swap_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatePayload_Swap_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Swap != nil { - { - size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - return len(dAtA) - i, nil -} -func (m *StatePayload_RolledUp) 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 *StatePayload_RolledUp) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatePayload_RolledUp) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Commitment != nil { - { - size, err := m.Commitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *StatePayload_Note) 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 *StatePayload_Note) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatePayload_Note) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Note != nil { - { - size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Source != nil { - { - size, err := m.Source.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *StatePayload_Swap) 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 *StatePayload_Swap) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatePayload_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Swap != nil { - { - size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Source != nil { - { - size, err := m.Source.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *KnownAssets) 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 *KnownAssets) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *KnownAssets) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Assets) > 0 { - for iNdEx := len(m.Assets) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Assets[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil -} - -func (m *NoteSource) 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 *NoteSource) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NoteSource) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintChain(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SpendInfo) 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 *SpendInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SpendInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.SpendHeight != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.SpendHeight)) - i-- - dAtA[i] = 0x10 - } - if m.NoteSource != nil { - { - size, err := m.NoteSource.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *GenesisAppState) 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 *GenesisAppState) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GenesisAppState) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Allocations) > 0 { - for iNdEx := len(m.Allocations) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Allocations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - } - if len(m.Validators) > 0 { - for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if m.ChainParams != nil { - { - size, err := m.ChainParams.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *GenesisAppState_Allocation) 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 *GenesisAppState_Allocation) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GenesisAppState_Allocation) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Address != nil { - { - size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if len(m.Denom) > 0 { - i -= len(m.Denom) - copy(dAtA[i:], m.Denom) - i = encodeVarintChain(dAtA, i, uint64(len(m.Denom))) - i-- - dAtA[i] = 0x12 - } - if m.Amount != nil { - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintChain(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Epoch) 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 *Epoch) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Epoch) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.StartHeight != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.StartHeight)) - i-- - dAtA[i] = 0x10 - } - if m.Index != 0 { - i = encodeVarintChain(dAtA, i, uint64(m.Index)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func encodeVarintChain(dAtA []byte, offset int, v uint64) int { - offset -= sovChain(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *ChainParameters) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.ChainId) - if l > 0 { - n += 1 + l + sovChain(uint64(l)) - } - if m.EpochDuration != 0 { - n += 1 + sovChain(uint64(m.EpochDuration)) - } - if m.UnbondingEpochs != 0 { - n += 1 + sovChain(uint64(m.UnbondingEpochs)) - } - if m.ActiveValidatorLimit != 0 { - n += 1 + sovChain(uint64(m.ActiveValidatorLimit)) - } - if m.SlashingPenaltyMisbehavior != 0 { - n += 1 + sovChain(uint64(m.SlashingPenaltyMisbehavior)) - } - if m.IbcEnabled { - n += 2 - } - if m.InboundIcs20TransfersEnabled { - n += 2 - } - if m.OutboundIcs20TransfersEnabled { - n += 2 - } - if m.BaseRewardRate != 0 { - n += 1 + sovChain(uint64(m.BaseRewardRate)) - } - if m.SlashingPenaltyDowntime != 0 { - n += 1 + sovChain(uint64(m.SlashingPenaltyDowntime)) - } - if m.SignedBlocksWindowLen != 0 { - n += 1 + sovChain(uint64(m.SignedBlocksWindowLen)) - } - if m.MissedBlocksMaximum != 0 { - n += 1 + sovChain(uint64(m.MissedBlocksMaximum)) - } - if m.ProposalVotingBlocks != 0 { - n += 2 + sovChain(uint64(m.ProposalVotingBlocks)) - } - if m.ProposalDepositAmount != nil { - l = m.ProposalDepositAmount.Size() - n += 2 + l + sovChain(uint64(l)) - } - l = len(m.ProposalValidQuorum) - if l > 0 { - n += 2 + l + sovChain(uint64(l)) - } - l = len(m.ProposalPassThreshold) - if l > 0 { - n += 2 + l + sovChain(uint64(l)) - } - l = len(m.ProposalSlashThreshold) - if l > 0 { - n += 2 + l + sovChain(uint64(l)) - } - if m.DaoSpendProposalsEnabled { - n += 3 - } - return n -} - -func (m *Ratio) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Numerator != 0 { - n += 1 + sovChain(uint64(m.Numerator)) - } - if m.Denominator != 0 { - n += 1 + sovChain(uint64(m.Denominator)) - } - return n -} - -func (m *FmdParameters) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PrecisionBits != 0 { - n += 1 + sovChain(uint64(m.PrecisionBits)) - } - if m.AsOfBlockHeight != 0 { - n += 1 + sovChain(uint64(m.AsOfBlockHeight)) - } - return n -} - -func (m *CompactBlock) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Height != 0 { - n += 1 + sovChain(uint64(m.Height)) - } - if len(m.StatePayloads) > 0 { - for _, e := range m.StatePayloads { - l = e.Size() - n += 1 + l + sovChain(uint64(l)) - } - } - if len(m.Nullifiers) > 0 { - for _, e := range m.Nullifiers { - l = e.Size() - n += 1 + l + sovChain(uint64(l)) - } - } - if m.BlockRoot != nil { - l = m.BlockRoot.Size() - n += 1 + l + sovChain(uint64(l)) - } - if len(m.SwapOutputs) > 0 { - for _, e := range m.SwapOutputs { - l = e.Size() - n += 1 + l + sovChain(uint64(l)) - } - } - if m.ChainParameters != nil { - l = m.ChainParameters.Size() - n += 1 + l + sovChain(uint64(l)) - } - if m.EpochRoot != nil { - l = m.EpochRoot.Size() - n += 2 + l + sovChain(uint64(l)) - } - if m.ProposalStarted { - n += 3 - } - if m.FmdParameters != nil { - l = m.FmdParameters.Size() - n += 2 + l + sovChain(uint64(l)) - } - return n -} - -func (m *StatePayload) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.StatePayload != nil { - n += m.StatePayload.Size() - } - return n -} - -func (m *StatePayload_RolledUp_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.RolledUp != nil { - l = m.RolledUp.Size() - n += 1 + l + sovChain(uint64(l)) - } - return n -} -func (m *StatePayload_Note_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Note != nil { - l = m.Note.Size() - n += 1 + l + sovChain(uint64(l)) - } - return n -} -func (m *StatePayload_Swap_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Swap != nil { - l = m.Swap.Size() - n += 1 + l + sovChain(uint64(l)) - } - return n -} -func (m *StatePayload_RolledUp) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Commitment != nil { - l = m.Commitment.Size() - n += 1 + l + sovChain(uint64(l)) - } - return n -} - -func (m *StatePayload_Note) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Source != nil { - l = m.Source.Size() - n += 1 + l + sovChain(uint64(l)) - } - if m.Note != nil { - l = m.Note.Size() - n += 1 + l + sovChain(uint64(l)) - } - return n -} - -func (m *StatePayload_Swap) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Source != nil { - l = m.Source.Size() - n += 1 + l + sovChain(uint64(l)) - } - if m.Swap != nil { - l = m.Swap.Size() - n += 1 + l + sovChain(uint64(l)) - } - return n -} - -func (m *KnownAssets) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Assets) > 0 { - for _, e := range m.Assets { - l = e.Size() - n += 1 + l + sovChain(uint64(l)) - } - } - return n -} - -func (m *NoteSource) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovChain(uint64(l)) - } - return n -} - -func (m *SpendInfo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.NoteSource != nil { - l = m.NoteSource.Size() - n += 1 + l + sovChain(uint64(l)) - } - if m.SpendHeight != 0 { - n += 1 + sovChain(uint64(m.SpendHeight)) - } - return n -} - -func (m *GenesisAppState) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ChainParams != nil { - l = m.ChainParams.Size() - n += 1 + l + sovChain(uint64(l)) - } - if len(m.Validators) > 0 { - for _, e := range m.Validators { - l = e.Size() - n += 1 + l + sovChain(uint64(l)) - } - } - if len(m.Allocations) > 0 { - for _, e := range m.Allocations { - l = e.Size() - n += 1 + l + sovChain(uint64(l)) - } - } - return n -} - -func (m *GenesisAppState_Allocation) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Amount != nil { - l = m.Amount.Size() - n += 1 + l + sovChain(uint64(l)) - } - l = len(m.Denom) - if l > 0 { - n += 1 + l + sovChain(uint64(l)) - } - if m.Address != nil { - l = m.Address.Size() - n += 1 + l + sovChain(uint64(l)) - } - return n -} - -func (m *Epoch) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Index != 0 { - n += 1 + sovChain(uint64(m.Index)) - } - if m.StartHeight != 0 { - n += 1 + sovChain(uint64(m.StartHeight)) - } - return n -} - -func sovChain(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozChain(x uint64) (n int) { - return sovChain(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *ChainParameters) 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 ErrIntOverflowChain - } - 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: ChainParameters: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ChainParameters: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - 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 ErrInvalidLengthChain - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ChainId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EpochDuration", wireType) - } - m.EpochDuration = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.EpochDuration |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field UnbondingEpochs", wireType) - } - m.UnbondingEpochs = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.UnbondingEpochs |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ActiveValidatorLimit", wireType) - } - m.ActiveValidatorLimit = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ActiveValidatorLimit |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyMisbehavior", wireType) - } - m.SlashingPenaltyMisbehavior = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.SlashingPenaltyMisbehavior |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IbcEnabled", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IbcEnabled = bool(v != 0) - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field InboundIcs20TransfersEnabled", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.InboundIcs20TransfersEnabled = bool(v != 0) - case 8: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field OutboundIcs20TransfersEnabled", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.OutboundIcs20TransfersEnabled = bool(v != 0) - case 9: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType) - } - m.BaseRewardRate = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.BaseRewardRate |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 10: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyDowntime", wireType) - } - m.SlashingPenaltyDowntime = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.SlashingPenaltyDowntime |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 11: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SignedBlocksWindowLen", wireType) - } - m.SignedBlocksWindowLen = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.SignedBlocksWindowLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 12: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MissedBlocksMaximum", wireType) - } - m.MissedBlocksMaximum = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MissedBlocksMaximum |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 20: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalVotingBlocks", wireType) - } - m.ProposalVotingBlocks = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ProposalVotingBlocks |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 21: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositAmount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ProposalDepositAmount == nil { - m.ProposalDepositAmount = &v1alpha1.Amount{} - } - if err := m.ProposalDepositAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 22: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalValidQuorum", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - 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 ErrInvalidLengthChain - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProposalValidQuorum = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 23: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalPassThreshold", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - 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 ErrInvalidLengthChain - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProposalPassThreshold = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 24: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalSlashThreshold", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - 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 ErrInvalidLengthChain - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProposalSlashThreshold = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 25: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoSpendProposalsEnabled", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.DaoSpendProposalsEnabled = bool(v != 0) - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Ratio) 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 ErrIntOverflowChain - } - 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: Ratio: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Ratio: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Numerator", wireType) - } - m.Numerator = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Numerator |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Denominator", wireType) - } - m.Denominator = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Denominator |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *FmdParameters) 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 ErrIntOverflowChain - } - 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: FmdParameters: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: FmdParameters: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PrecisionBits", wireType) - } - m.PrecisionBits = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.PrecisionBits |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AsOfBlockHeight", wireType) - } - m.AsOfBlockHeight = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AsOfBlockHeight |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *CompactBlock) 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 ErrIntOverflowChain - } - 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: CompactBlock: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: CompactBlock: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) - } - m.Height = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Height |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StatePayloads", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.StatePayloads = append(m.StatePayloads, &StatePayload{}) - if err := m.StatePayloads[len(m.StatePayloads)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Nullifiers", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Nullifiers = append(m.Nullifiers, &v1alpha1.Nullifier{}) - if err := m.Nullifiers[len(m.Nullifiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.BlockRoot == nil { - m.BlockRoot = &v1alpha1.MerkleRoot{} - } - if err := m.BlockRoot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapOutputs", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SwapOutputs = append(m.SwapOutputs, &v1alpha11.BatchSwapOutputData{}) - if err := m.SwapOutputs[len(m.SwapOutputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChainParameters", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ChainParameters == nil { - m.ChainParameters = &ChainParameters{} - } - if err := m.ChainParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 17: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EpochRoot", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.EpochRoot == nil { - m.EpochRoot = &v1alpha1.MerkleRoot{} - } - if err := m.EpochRoot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 20: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalStarted", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.ProposalStarted = bool(v != 0) - case 100: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FmdParameters", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.FmdParameters == nil { - m.FmdParameters = &FmdParameters{} - } - if err := m.FmdParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StatePayload) 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 ErrIntOverflowChain - } - 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: StatePayload: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StatePayload: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RolledUp", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &StatePayload_RolledUp{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.StatePayload = &StatePayload_RolledUp_{v} - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &StatePayload_Note{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.StatePayload = &StatePayload_Note_{v} - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &StatePayload_Swap{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.StatePayload = &StatePayload_Swap_{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StatePayload_RolledUp) 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 ErrIntOverflowChain - } - 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: RolledUp: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RolledUp: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Commitment", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Commitment == nil { - m.Commitment = &v1alpha1.StateCommitment{} - } - if err := m.Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StatePayload_Note) 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 ErrIntOverflowChain - } - 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: Note: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Note: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Source == nil { - m.Source = &NoteSource{} - } - if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Note == nil { - m.Note = &v1alpha1.NotePayload{} - } - if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StatePayload_Swap) 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 ErrIntOverflowChain - } - 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: Swap: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Swap: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Source == nil { - m.Source = &NoteSource{} - } - if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Swap == nil { - m.Swap = &v1alpha11.SwapPayload{} - } - if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *KnownAssets) 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 ErrIntOverflowChain - } - 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: KnownAssets: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: KnownAssets: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Assets", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Assets = append(m.Assets, &v1alpha1.DenomMetadata{}) - if err := m.Assets[len(m.Assets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *NoteSource) 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 ErrIntOverflowChain - } - 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: NoteSource: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: NoteSource: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SpendInfo) 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 ErrIntOverflowChain - } - 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: SpendInfo: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SpendInfo: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NoteSource", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.NoteSource == nil { - m.NoteSource = &NoteSource{} - } - if err := m.NoteSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SpendHeight", wireType) - } - m.SpendHeight = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.SpendHeight |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *GenesisAppState) 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 ErrIntOverflowChain - } - 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: GenesisAppState: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GenesisAppState: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChainParams", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ChainParams == nil { - m.ChainParams = &ChainParameters{} - } - if err := m.ChainParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Validators = append(m.Validators, &v1alpha12.Validator{}) - if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Allocations", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Allocations = append(m.Allocations, &GenesisAppState_Allocation{}) - if err := m.Allocations[len(m.Allocations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *GenesisAppState_Allocation) 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 ErrIntOverflowChain - } - 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: Allocation: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Allocation: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Amount == nil { - m.Amount = &v1alpha1.Amount{} - } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - 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 ErrInvalidLengthChain - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Denom = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthChain - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthChain - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Address == nil { - m.Address = &v1alpha1.Address{} - } - if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Epoch) 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 ErrIntOverflowChain - } - 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: Epoch: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Epoch: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) - } - m.Index = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Index |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType) - } - m.StartHeight = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChain - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StartHeight |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipChain(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthChain - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipChain(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, ErrIntOverflowChain - } - 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, ErrIntOverflowChain - } - 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, ErrIntOverflowChain - } - 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, ErrInvalidLengthChain - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupChain - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthChain - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthChain = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowChain = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupChain = fmt.Errorf("proto: unexpected end of group") -) diff --git a/relayer/chains/penumbra/core/component/chain/v1alpha1/chain.pb.go b/relayer/chains/penumbra/core/component/chain/v1alpha1/chain.pb.go new file mode 100644 index 000000000..8c4d79f83 --- /dev/null +++ b/relayer/chains/penumbra/core/component/chain/v1alpha1/chain.pb.go @@ -0,0 +1,1553 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/chain/v1alpha1/chain.proto + +package chainv1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +// Global chain configuration data, such as chain ID, epoch duration, etc. +type ChainParameters struct { + // The identifier of the chain. + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The duration of each epoch, in number of blocks. + EpochDuration uint64 `protobuf:"varint,2,opt,name=epoch_duration,json=epochDuration,proto3" json:"epoch_duration,omitempty"` +} + +func (m *ChainParameters) Reset() { *m = ChainParameters{} } +func (m *ChainParameters) String() string { return proto.CompactTextString(m) } +func (*ChainParameters) ProtoMessage() {} +func (*ChainParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_aca0b6fc4499b003, []int{0} +} +func (m *ChainParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChainParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChainParameters.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 *ChainParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChainParameters.Merge(m, src) +} +func (m *ChainParameters) XXX_Size() int { + return m.Size() +} +func (m *ChainParameters) XXX_DiscardUnknown() { + xxx_messageInfo_ChainParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_ChainParameters proto.InternalMessageInfo + +func (m *ChainParameters) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *ChainParameters) GetEpochDuration() uint64 { + if m != nil { + return m.EpochDuration + } + return 0 +} + +// The ratio between two numbers, used in governance to describe vote thresholds and quorums. +type Ratio struct { + // The numerator. + Numerator uint64 `protobuf:"varint,1,opt,name=numerator,proto3" json:"numerator,omitempty"` + // The denominator. + Denominator uint64 `protobuf:"varint,2,opt,name=denominator,proto3" json:"denominator,omitempty"` +} + +func (m *Ratio) Reset() { *m = Ratio{} } +func (m *Ratio) String() string { return proto.CompactTextString(m) } +func (*Ratio) ProtoMessage() {} +func (*Ratio) Descriptor() ([]byte, []int) { + return fileDescriptor_aca0b6fc4499b003, []int{1} +} +func (m *Ratio) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Ratio) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Ratio.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 *Ratio) XXX_Merge(src proto.Message) { + xxx_messageInfo_Ratio.Merge(m, src) +} +func (m *Ratio) XXX_Size() int { + return m.Size() +} +func (m *Ratio) XXX_DiscardUnknown() { + xxx_messageInfo_Ratio.DiscardUnknown(m) +} + +var xxx_messageInfo_Ratio proto.InternalMessageInfo + +func (m *Ratio) GetNumerator() uint64 { + if m != nil { + return m.Numerator + } + return 0 +} + +func (m *Ratio) GetDenominator() uint64 { + if m != nil { + return m.Denominator + } + return 0 +} + +// Parameters for Fuzzy Message Detection +type FmdParameters struct { + PrecisionBits uint32 `protobuf:"varint,1,opt,name=precision_bits,json=precisionBits,proto3" json:"precision_bits,omitempty"` + AsOfBlockHeight uint64 `protobuf:"varint,2,opt,name=as_of_block_height,json=asOfBlockHeight,proto3" json:"as_of_block_height,omitempty"` +} + +func (m *FmdParameters) Reset() { *m = FmdParameters{} } +func (m *FmdParameters) String() string { return proto.CompactTextString(m) } +func (*FmdParameters) ProtoMessage() {} +func (*FmdParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_aca0b6fc4499b003, []int{2} +} +func (m *FmdParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FmdParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FmdParameters.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 *FmdParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_FmdParameters.Merge(m, src) +} +func (m *FmdParameters) XXX_Size() int { + return m.Size() +} +func (m *FmdParameters) XXX_DiscardUnknown() { + xxx_messageInfo_FmdParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_FmdParameters proto.InternalMessageInfo + +func (m *FmdParameters) GetPrecisionBits() uint32 { + if m != nil { + return m.PrecisionBits + } + return 0 +} + +func (m *FmdParameters) GetAsOfBlockHeight() uint64 { + if m != nil { + return m.AsOfBlockHeight + } + return 0 +} + +// Chain-specific genesis content. +type GenesisContent struct { + // The ChainParameters present at genesis. + ChainParams *ChainParameters `protobuf:"bytes,1,opt,name=chain_params,json=chainParams,proto3" json:"chain_params,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_aca0b6fc4499b003, []int{3} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.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 *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetChainParams() *ChainParameters { + if m != nil { + return m.ChainParams + } + return nil +} + +type Epoch struct { + Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + StartHeight uint64 `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` +} + +func (m *Epoch) Reset() { *m = Epoch{} } +func (m *Epoch) String() string { return proto.CompactTextString(m) } +func (*Epoch) ProtoMessage() {} +func (*Epoch) Descriptor() ([]byte, []int) { + return fileDescriptor_aca0b6fc4499b003, []int{4} +} +func (m *Epoch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Epoch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Epoch.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 *Epoch) XXX_Merge(src proto.Message) { + xxx_messageInfo_Epoch.Merge(m, src) +} +func (m *Epoch) XXX_Size() int { + return m.Size() +} +func (m *Epoch) XXX_DiscardUnknown() { + xxx_messageInfo_Epoch.DiscardUnknown(m) +} + +var xxx_messageInfo_Epoch proto.InternalMessageInfo + +func (m *Epoch) GetIndex() uint64 { + if m != nil { + return m.Index + } + return 0 +} + +func (m *Epoch) GetStartHeight() uint64 { + if m != nil { + return m.StartHeight + } + return 0 +} + +type EpochByHeightRequest struct { + Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *EpochByHeightRequest) Reset() { *m = EpochByHeightRequest{} } +func (m *EpochByHeightRequest) String() string { return proto.CompactTextString(m) } +func (*EpochByHeightRequest) ProtoMessage() {} +func (*EpochByHeightRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_aca0b6fc4499b003, []int{5} +} +func (m *EpochByHeightRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EpochByHeightRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EpochByHeightRequest.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 *EpochByHeightRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_EpochByHeightRequest.Merge(m, src) +} +func (m *EpochByHeightRequest) XXX_Size() int { + return m.Size() +} +func (m *EpochByHeightRequest) XXX_DiscardUnknown() { + xxx_messageInfo_EpochByHeightRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_EpochByHeightRequest proto.InternalMessageInfo + +func (m *EpochByHeightRequest) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +type EpochByHeightResponse struct { + Epoch *Epoch `protobuf:"bytes,1,opt,name=epoch,proto3" json:"epoch,omitempty"` +} + +func (m *EpochByHeightResponse) Reset() { *m = EpochByHeightResponse{} } +func (m *EpochByHeightResponse) String() string { return proto.CompactTextString(m) } +func (*EpochByHeightResponse) ProtoMessage() {} +func (*EpochByHeightResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_aca0b6fc4499b003, []int{6} +} +func (m *EpochByHeightResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EpochByHeightResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EpochByHeightResponse.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 *EpochByHeightResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_EpochByHeightResponse.Merge(m, src) +} +func (m *EpochByHeightResponse) XXX_Size() int { + return m.Size() +} +func (m *EpochByHeightResponse) XXX_DiscardUnknown() { + xxx_messageInfo_EpochByHeightResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_EpochByHeightResponse proto.InternalMessageInfo + +func (m *EpochByHeightResponse) GetEpoch() *Epoch { + if m != nil { + return m.Epoch + } + return nil +} + +func init() { + proto.RegisterType((*ChainParameters)(nil), "penumbra.core.component.chain.v1alpha1.ChainParameters") + proto.RegisterType((*Ratio)(nil), "penumbra.core.component.chain.v1alpha1.Ratio") + proto.RegisterType((*FmdParameters)(nil), "penumbra.core.component.chain.v1alpha1.FmdParameters") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.chain.v1alpha1.GenesisContent") + proto.RegisterType((*Epoch)(nil), "penumbra.core.component.chain.v1alpha1.Epoch") + proto.RegisterType((*EpochByHeightRequest)(nil), "penumbra.core.component.chain.v1alpha1.EpochByHeightRequest") + proto.RegisterType((*EpochByHeightResponse)(nil), "penumbra.core.component.chain.v1alpha1.EpochByHeightResponse") +} + +func init() { + proto.RegisterFile("penumbra/core/component/chain/v1alpha1/chain.proto", fileDescriptor_aca0b6fc4499b003) +} + +var fileDescriptor_aca0b6fc4499b003 = []byte{ + // 581 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x4f, 0x6b, 0xd4, 0x4e, + 0x18, 0x6e, 0x42, 0xb7, 0xbf, 0x5f, 0x67, 0xbb, 0x2d, 0x0c, 0x55, 0xaa, 0x48, 0xa8, 0x81, 0x96, + 0x52, 0x31, 0xa1, 0xeb, 0x41, 0x88, 0x0a, 0x92, 0xa8, 0xab, 0x07, 0x71, 0x4d, 0xc1, 0x43, 0x09, + 0xc4, 0xd9, 0x64, 0xda, 0x0c, 0x6e, 0x66, 0xe2, 0xcc, 0x64, 0x71, 0xbf, 0x83, 0x07, 0xbf, 0x80, + 0x17, 0x8f, 0x7e, 0x12, 0xf1, 0xd4, 0xa3, 0x47, 0xd9, 0xbd, 0x79, 0xf1, 0x2b, 0xc8, 0x4c, 0xfe, + 0xb4, 0xdd, 0xd3, 0xea, 0x65, 0x99, 0xf7, 0xd9, 0xe7, 0x79, 0xde, 0xe7, 0x7d, 0x87, 0x09, 0xe8, + 0x17, 0x98, 0x96, 0xf9, 0x88, 0x23, 0x37, 0x61, 0x1c, 0xbb, 0x09, 0xcb, 0x0b, 0x46, 0x31, 0x95, + 0x6e, 0x92, 0x21, 0x42, 0xdd, 0xc9, 0x11, 0x1a, 0x17, 0x19, 0x3a, 0xaa, 0x4a, 0xa7, 0xe0, 0x4c, + 0x32, 0xb8, 0xdf, 0x68, 0x1c, 0xa5, 0x71, 0x5a, 0x8d, 0x53, 0x91, 0x1a, 0x8d, 0x7d, 0x0c, 0xb6, + 0x02, 0x85, 0x0c, 0x11, 0x47, 0x39, 0x96, 0x98, 0x0b, 0x78, 0x03, 0xfc, 0xaf, 0x49, 0x31, 0x49, + 0x77, 0x8c, 0x5d, 0xe3, 0x60, 0x3d, 0xfc, 0x4f, 0xd7, 0x2f, 0x52, 0xb8, 0x07, 0x36, 0x71, 0xc1, + 0x92, 0x2c, 0x4e, 0x4b, 0x8e, 0x24, 0x61, 0x74, 0xc7, 0xdc, 0x35, 0x0e, 0x56, 0xc3, 0x9e, 0x46, + 0x9f, 0xd4, 0xa0, 0x3d, 0x00, 0x9d, 0x50, 0x9d, 0xe0, 0x2d, 0xb0, 0x4e, 0xcb, 0x1c, 0x73, 0x24, + 0x19, 0xd7, 0x5e, 0xab, 0xe1, 0x05, 0x00, 0x77, 0x41, 0x37, 0xc5, 0x94, 0xe5, 0x84, 0xea, 0xff, + 0x2b, 0xab, 0xcb, 0x90, 0x9d, 0x80, 0xde, 0xb3, 0x3c, 0xbd, 0x94, 0x6d, 0x0f, 0x6c, 0x16, 0x1c, + 0x27, 0x44, 0x10, 0x46, 0xe3, 0x11, 0x91, 0x42, 0xbb, 0xf6, 0xc2, 0x5e, 0x8b, 0xfa, 0x44, 0x0a, + 0x78, 0x07, 0x40, 0x24, 0x62, 0x76, 0x1a, 0x8f, 0xc6, 0x2c, 0x79, 0x17, 0x67, 0x98, 0x9c, 0x65, + 0xb2, 0x6e, 0xb0, 0x85, 0xc4, 0xab, 0x53, 0x5f, 0xe1, 0xcf, 0x35, 0x6c, 0x8f, 0xc1, 0xe6, 0x00, + 0x53, 0x2c, 0x88, 0x08, 0x18, 0x95, 0x98, 0x4a, 0x78, 0x02, 0x36, 0xaa, 0x0d, 0x14, 0xaa, 0x73, + 0xd5, 0xa3, 0xdb, 0xbf, 0xef, 0x2c, 0xb7, 0x53, 0x67, 0x61, 0xa1, 0x61, 0x37, 0x69, 0x01, 0x61, + 0x3f, 0x06, 0x9d, 0xa7, 0x6a, 0x59, 0x70, 0x1b, 0x74, 0x08, 0x4d, 0xf1, 0x87, 0x7a, 0x2f, 0x55, + 0x01, 0x6f, 0x83, 0x0d, 0x21, 0x11, 0x97, 0x57, 0x33, 0x77, 0x35, 0x56, 0xe7, 0x75, 0xc0, 0xb6, + 0x76, 0xf0, 0xa7, 0x15, 0x10, 0xe2, 0xf7, 0x25, 0x16, 0x12, 0x5e, 0x07, 0x6b, 0xb5, 0xa8, 0x72, + 0xac, 0x2b, 0x3b, 0x02, 0xd7, 0x16, 0xf8, 0xa2, 0x60, 0x54, 0x60, 0x18, 0x80, 0x8e, 0xbe, 0xb7, + 0x7a, 0xbe, 0xbb, 0xcb, 0xce, 0xa7, 0xdd, 0xc2, 0x4a, 0xdb, 0xff, 0x6c, 0x80, 0x8d, 0xd7, 0x25, + 0xe6, 0xd3, 0x63, 0xcc, 0x27, 0x24, 0xc1, 0xf0, 0xa3, 0x01, 0x7a, 0x57, 0xfa, 0xc1, 0x87, 0x7f, + 0x65, 0xbc, 0x30, 0xd6, 0xcd, 0x47, 0xff, 0xa8, 0xae, 0x86, 0xf4, 0x7f, 0x9b, 0xdf, 0x66, 0x96, + 0x71, 0x3e, 0xb3, 0x8c, 0x9f, 0x33, 0xcb, 0xf8, 0x34, 0xb7, 0x56, 0xce, 0xe7, 0xd6, 0xca, 0x8f, + 0xb9, 0xb5, 0x02, 0x0e, 0x13, 0x96, 0x2f, 0x69, 0xee, 0x83, 0xea, 0x52, 0xd5, 0xdb, 0x1a, 0x1a, + 0x27, 0x6f, 0xcf, 0x88, 0xcc, 0xca, 0x91, 0xa2, 0xbb, 0x09, 0x13, 0x39, 0x13, 0x2e, 0xc7, 0x63, + 0x34, 0xc5, 0xdc, 0x9d, 0xf4, 0xdb, 0xa3, 0xb6, 0x10, 0xee, 0x72, 0xaf, 0xf7, 0x81, 0x2e, 0x9b, + 0xea, 0x8b, 0xb9, 0x3a, 0x0c, 0x82, 0xe0, 0xab, 0xb9, 0x3f, 0x6c, 0xf2, 0x05, 0x2a, 0x5f, 0xd0, + 0xe6, 0xd3, 0x79, 0x9c, 0x37, 0x35, 0xff, 0xfb, 0x05, 0x31, 0x52, 0xc4, 0xa8, 0x25, 0x46, 0x9a, + 0x18, 0x35, 0xc4, 0x99, 0xd9, 0x5f, 0x8e, 0x18, 0x0d, 0x86, 0xfe, 0x4b, 0x2c, 0x51, 0x8a, 0x24, + 0xfa, 0x65, 0x1e, 0x36, 0x22, 0xcf, 0x53, 0x2a, 0xf5, 0x5b, 0xcb, 0x3c, 0x4f, 0xeb, 0x3c, 0xaf, + 0x11, 0x8e, 0xd6, 0xf4, 0x17, 0xe8, 0xde, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb6, 0xbd, 0x1b, + 0x4f, 0xb7, 0x04, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + // TODO: move to SCT cf sct/src/component/view.rs:9 "make epoch management the responsibility of this component" + EpochByHeight(ctx context.Context, in *EpochByHeightRequest, opts ...grpc.CallOption) (*EpochByHeightResponse, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) EpochByHeight(ctx context.Context, in *EpochByHeightRequest, opts ...grpc.CallOption) (*EpochByHeightResponse, error) { + out := new(EpochByHeightResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.chain.v1alpha1.QueryService/EpochByHeight", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + // TODO: move to SCT cf sct/src/component/view.rs:9 "make epoch management the responsibility of this component" + EpochByHeight(context.Context, *EpochByHeightRequest) (*EpochByHeightResponse, error) +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) EpochByHeight(ctx context.Context, req *EpochByHeightRequest) (*EpochByHeightResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EpochByHeight not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_EpochByHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EpochByHeightRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).EpochByHeight(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.chain.v1alpha1.QueryService/EpochByHeight", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).EpochByHeight(ctx, req.(*EpochByHeightRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.chain.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "EpochByHeight", + Handler: _QueryService_EpochByHeight_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "penumbra/core/component/chain/v1alpha1/chain.proto", +} + +func (m *ChainParameters) 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 *ChainParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChainParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EpochDuration != 0 { + i = encodeVarintChain(dAtA, i, uint64(m.EpochDuration)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintChain(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Ratio) 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 *Ratio) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Ratio) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Denominator != 0 { + i = encodeVarintChain(dAtA, i, uint64(m.Denominator)) + i-- + dAtA[i] = 0x10 + } + if m.Numerator != 0 { + i = encodeVarintChain(dAtA, i, uint64(m.Numerator)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *FmdParameters) 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 *FmdParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FmdParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AsOfBlockHeight != 0 { + i = encodeVarintChain(dAtA, i, uint64(m.AsOfBlockHeight)) + i-- + dAtA[i] = 0x10 + } + if m.PrecisionBits != 0 { + i = encodeVarintChain(dAtA, i, uint64(m.PrecisionBits)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ChainParams != nil { + { + size, err := m.ChainParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintChain(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Epoch) 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 *Epoch) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Epoch) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.StartHeight != 0 { + i = encodeVarintChain(dAtA, i, uint64(m.StartHeight)) + i-- + dAtA[i] = 0x10 + } + if m.Index != 0 { + i = encodeVarintChain(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EpochByHeightRequest) 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 *EpochByHeightRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EpochByHeightRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintChain(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EpochByHeightResponse) 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 *EpochByHeightResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EpochByHeightResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Epoch != nil { + { + size, err := m.Epoch.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintChain(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintChain(dAtA []byte, offset int, v uint64) int { + offset -= sovChain(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ChainParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovChain(uint64(l)) + } + if m.EpochDuration != 0 { + n += 1 + sovChain(uint64(m.EpochDuration)) + } + return n +} + +func (m *Ratio) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Numerator != 0 { + n += 1 + sovChain(uint64(m.Numerator)) + } + if m.Denominator != 0 { + n += 1 + sovChain(uint64(m.Denominator)) + } + return n +} + +func (m *FmdParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PrecisionBits != 0 { + n += 1 + sovChain(uint64(m.PrecisionBits)) + } + if m.AsOfBlockHeight != 0 { + n += 1 + sovChain(uint64(m.AsOfBlockHeight)) + } + return n +} + +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ChainParams != nil { + l = m.ChainParams.Size() + n += 1 + l + sovChain(uint64(l)) + } + return n +} + +func (m *Epoch) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != 0 { + n += 1 + sovChain(uint64(m.Index)) + } + if m.StartHeight != 0 { + n += 1 + sovChain(uint64(m.StartHeight)) + } + return n +} + +func (m *EpochByHeightRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovChain(uint64(m.Height)) + } + return n +} + +func (m *EpochByHeightResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.Size() + n += 1 + l + sovChain(uint64(l)) + } + return n +} + +func sovChain(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozChain(x uint64) (n int) { + return sovChain(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ChainParameters) 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 ErrIntOverflowChain + } + 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: ChainParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ChainParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + 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 ErrInvalidLengthChain + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthChain + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochDuration", wireType) + } + m.EpochDuration = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EpochDuration |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipChain(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthChain + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Ratio) 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 ErrIntOverflowChain + } + 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: Ratio: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Ratio: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Numerator", wireType) + } + m.Numerator = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Numerator |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Denominator", wireType) + } + m.Denominator = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Denominator |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipChain(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthChain + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FmdParameters) 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 ErrIntOverflowChain + } + 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: FmdParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FmdParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrecisionBits", wireType) + } + m.PrecisionBits = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PrecisionBits |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AsOfBlockHeight", wireType) + } + m.AsOfBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AsOfBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipChain(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthChain + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent) 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 ErrIntOverflowChain + } + 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: GenesisContent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthChain + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthChain + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChainParams == nil { + m.ChainParams = &ChainParameters{} + } + if err := m.ChainParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipChain(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthChain + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Epoch) 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 ErrIntOverflowChain + } + 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: Epoch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Epoch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType) + } + m.StartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipChain(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthChain + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EpochByHeightRequest) 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 ErrIntOverflowChain + } + 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: EpochByHeightRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EpochByHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipChain(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthChain + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EpochByHeightResponse) 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 ErrIntOverflowChain + } + 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: EpochByHeightResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EpochByHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChain + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthChain + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthChain + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = &Epoch{} + } + if err := m.Epoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipChain(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthChain + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipChain(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, ErrIntOverflowChain + } + 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, ErrIntOverflowChain + } + 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, ErrIntOverflowChain + } + 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, ErrInvalidLengthChain + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupChain + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthChain + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthChain = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowChain = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupChain = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/component/community_pool/v1alpha1/community_pool.pb.go b/relayer/chains/penumbra/core/component/community_pool/v1alpha1/community_pool.pb.go new file mode 100644 index 000000000..d370f4a26 --- /dev/null +++ b/relayer/chains/penumbra/core/component/community_pool/v1alpha1/community_pool.pb.go @@ -0,0 +1,1042 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/community_pool/v1alpha1/community_pool.proto + +package community_poolv1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +// CommunityPool parameter data. +type CommunityPoolParameters struct { + // Whether Community Pool spend proposals are enabled. + CommunityPoolSpendProposalsEnabled bool `protobuf:"varint,1,opt,name=community_pool_spend_proposals_enabled,json=communityPoolSpendProposalsEnabled,proto3" json:"community_pool_spend_proposals_enabled,omitempty"` +} + +func (m *CommunityPoolParameters) Reset() { *m = CommunityPoolParameters{} } +func (m *CommunityPoolParameters) String() string { return proto.CompactTextString(m) } +func (*CommunityPoolParameters) ProtoMessage() {} +func (*CommunityPoolParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_cbd96600126596ed, []int{0} +} +func (m *CommunityPoolParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommunityPoolParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommunityPoolParameters.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 *CommunityPoolParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommunityPoolParameters.Merge(m, src) +} +func (m *CommunityPoolParameters) XXX_Size() int { + return m.Size() +} +func (m *CommunityPoolParameters) XXX_DiscardUnknown() { + xxx_messageInfo_CommunityPoolParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_CommunityPoolParameters proto.InternalMessageInfo + +func (m *CommunityPoolParameters) GetCommunityPoolSpendProposalsEnabled() bool { + if m != nil { + return m.CommunityPoolSpendProposalsEnabled + } + return false +} + +// CommunityPool genesis state. +type GenesisContent struct { + // CommunityPool parameters. + CommunityPoolParams *CommunityPoolParameters `protobuf:"bytes,1,opt,name=community_pool_params,json=communityPoolParams,proto3" json:"community_pool_params,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_cbd96600126596ed, []int{1} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.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 *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetCommunityPoolParams() *CommunityPoolParameters { + if m != nil { + return m.CommunityPoolParams + } + return nil +} + +// Requests the list of all asset balances associated with the Community Pool. +type CommunityPoolAssetBalancesRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // (Optional): The specific asset balances to retrieve, if excluded all will be returned. + AssetIds []*v1alpha1.AssetId `protobuf:"bytes,2,rep,name=asset_ids,json=assetIds,proto3" json:"asset_ids,omitempty"` +} + +func (m *CommunityPoolAssetBalancesRequest) Reset() { *m = CommunityPoolAssetBalancesRequest{} } +func (m *CommunityPoolAssetBalancesRequest) String() string { return proto.CompactTextString(m) } +func (*CommunityPoolAssetBalancesRequest) ProtoMessage() {} +func (*CommunityPoolAssetBalancesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_cbd96600126596ed, []int{2} +} +func (m *CommunityPoolAssetBalancesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommunityPoolAssetBalancesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommunityPoolAssetBalancesRequest.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 *CommunityPoolAssetBalancesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommunityPoolAssetBalancesRequest.Merge(m, src) +} +func (m *CommunityPoolAssetBalancesRequest) XXX_Size() int { + return m.Size() +} +func (m *CommunityPoolAssetBalancesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CommunityPoolAssetBalancesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_CommunityPoolAssetBalancesRequest proto.InternalMessageInfo + +func (m *CommunityPoolAssetBalancesRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *CommunityPoolAssetBalancesRequest) GetAssetIds() []*v1alpha1.AssetId { + if m != nil { + return m.AssetIds + } + return nil +} + +// The Community Pool's balance of a single asset. +type CommunityPoolAssetBalancesResponse struct { + // The balance for a single asset. + Balance *v1alpha1.Value `protobuf:"bytes,1,opt,name=balance,proto3" json:"balance,omitempty"` +} + +func (m *CommunityPoolAssetBalancesResponse) Reset() { *m = CommunityPoolAssetBalancesResponse{} } +func (m *CommunityPoolAssetBalancesResponse) String() string { return proto.CompactTextString(m) } +func (*CommunityPoolAssetBalancesResponse) ProtoMessage() {} +func (*CommunityPoolAssetBalancesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_cbd96600126596ed, []int{3} +} +func (m *CommunityPoolAssetBalancesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommunityPoolAssetBalancesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommunityPoolAssetBalancesResponse.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 *CommunityPoolAssetBalancesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommunityPoolAssetBalancesResponse.Merge(m, src) +} +func (m *CommunityPoolAssetBalancesResponse) XXX_Size() int { + return m.Size() +} +func (m *CommunityPoolAssetBalancesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CommunityPoolAssetBalancesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CommunityPoolAssetBalancesResponse proto.InternalMessageInfo + +func (m *CommunityPoolAssetBalancesResponse) GetBalance() *v1alpha1.Value { + if m != nil { + return m.Balance + } + return nil +} + +func init() { + proto.RegisterType((*CommunityPoolParameters)(nil), "penumbra.core.component.community_pool.v1alpha1.CommunityPoolParameters") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.community_pool.v1alpha1.GenesisContent") + proto.RegisterType((*CommunityPoolAssetBalancesRequest)(nil), "penumbra.core.component.community_pool.v1alpha1.CommunityPoolAssetBalancesRequest") + proto.RegisterType((*CommunityPoolAssetBalancesResponse)(nil), "penumbra.core.component.community_pool.v1alpha1.CommunityPoolAssetBalancesResponse") +} + +func init() { + proto.RegisterFile("penumbra/core/component/community_pool/v1alpha1/community_pool.proto", fileDescriptor_cbd96600126596ed) +} + +var fileDescriptor_cbd96600126596ed = []byte{ + // 531 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x41, 0x8b, 0xd3, 0x40, + 0x14, 0xc7, 0x3b, 0x5d, 0x71, 0xbb, 0xb3, 0xe2, 0x21, 0x22, 0xae, 0x3d, 0x84, 0x35, 0xa2, 0xf4, + 0x94, 0xb8, 0xdd, 0x5b, 0xc5, 0x83, 0x8d, 0xb2, 0xee, 0x41, 0x88, 0x29, 0xec, 0x41, 0x0a, 0x61, + 0x9a, 0x3c, 0x6c, 0x20, 0x99, 0x19, 0x67, 0x26, 0x85, 0x82, 0x27, 0x3f, 0x80, 0xf8, 0x19, 0x3c, + 0x7a, 0xf4, 0x4b, 0x28, 0x9e, 0xf6, 0xb8, 0x47, 0x69, 0x6f, 0x7e, 0x0a, 0x99, 0xa4, 0x93, 0x9a, + 0xea, 0x2e, 0x14, 0xbd, 0x94, 0x37, 0xaf, 0xef, 0xf7, 0x7f, 0xef, 0xfd, 0x99, 0x09, 0x7e, 0xc6, + 0x81, 0x16, 0xf9, 0x44, 0x10, 0x2f, 0x66, 0x02, 0xbc, 0x98, 0xe5, 0x9c, 0x51, 0xa0, 0x4a, 0x47, + 0x79, 0x41, 0x53, 0x35, 0x8f, 0x38, 0x63, 0x99, 0x37, 0x3b, 0x22, 0x19, 0x9f, 0x92, 0xa3, 0x8d, + 0xbc, 0xcb, 0x05, 0x53, 0xcc, 0xf2, 0x8c, 0x8a, 0xab, 0x55, 0xdc, 0x5a, 0xc5, 0xdd, 0xa8, 0x36, + 0x2a, 0xdd, 0x5e, 0xb3, 0x2d, 0x91, 0x12, 0xd4, 0xba, 0x47, 0x79, 0xac, 0xa4, 0x9d, 0x1c, 0xdf, + 0xf1, 0x8d, 0x48, 0xc0, 0x58, 0x16, 0x10, 0x41, 0x72, 0x50, 0x20, 0xa4, 0x15, 0xe2, 0x87, 0x4d, + 0xfd, 0x48, 0x72, 0xa0, 0x49, 0xc4, 0x05, 0xe3, 0x4c, 0x92, 0x4c, 0x46, 0x40, 0xc9, 0x24, 0x83, + 0xe4, 0x00, 0x1d, 0xa2, 0x5e, 0x27, 0x74, 0xe2, 0xdf, 0x85, 0x46, 0xba, 0x36, 0x30, 0xa5, 0xcf, + 0xab, 0x4a, 0xe7, 0x03, 0xc2, 0x37, 0x4f, 0x80, 0x82, 0x4c, 0xa5, 0xcf, 0xa8, 0x02, 0xaa, 0xac, + 0x77, 0xf8, 0xf6, 0x46, 0x1b, 0xae, 0x67, 0x90, 0xa5, 0xea, 0x7e, 0xff, 0x85, 0xbb, 0xe5, 0xf2, + 0xee, 0x25, 0xfb, 0x84, 0xb7, 0xe2, 0x3f, 0xfe, 0x90, 0xce, 0x7b, 0x84, 0xef, 0x35, 0x80, 0xa7, + 0xda, 0x9c, 0x21, 0xc9, 0x08, 0x8d, 0x41, 0x86, 0xf0, 0xb6, 0x00, 0xa9, 0xac, 0xbb, 0xb8, 0x13, + 0x4f, 0x49, 0x4a, 0xa3, 0xb4, 0x5a, 0x76, 0x2f, 0xdc, 0x2d, 0xcf, 0xa7, 0x89, 0x35, 0xc4, 0x7b, + 0xa5, 0x9f, 0x51, 0x9a, 0xc8, 0x83, 0xf6, 0xe1, 0x4e, 0x6f, 0xbf, 0xff, 0x60, 0x63, 0xe4, 0xca, + 0xef, 0x7a, 0xbe, 0xb2, 0xc3, 0x69, 0x12, 0x76, 0x48, 0x15, 0x48, 0x27, 0xc6, 0xce, 0x55, 0x33, + 0x48, 0xce, 0xa8, 0x04, 0xeb, 0x09, 0xde, 0x9d, 0x54, 0xb9, 0x95, 0x35, 0xf7, 0xaf, 0xee, 0x73, + 0x46, 0xb2, 0x02, 0x42, 0xc3, 0xf4, 0x2f, 0x10, 0xbe, 0xf1, 0xaa, 0x00, 0x31, 0x1f, 0x81, 0x98, + 0xa5, 0x31, 0x58, 0x5f, 0x11, 0xee, 0x5e, 0xde, 0xd6, 0x0a, 0xff, 0xcd, 0xf8, 0xbf, 0xf9, 0xd8, + 0x1d, 0xfd, 0x57, 0xcd, 0xca, 0x97, 0x47, 0x68, 0xf8, 0x65, 0xe7, 0xdb, 0xc2, 0x46, 0xe7, 0x0b, + 0x1b, 0xfd, 0x58, 0xd8, 0xe8, 0xe3, 0xd2, 0x6e, 0x9d, 0x2f, 0xed, 0xd6, 0xc5, 0xd2, 0x6e, 0xe1, + 0xe3, 0x98, 0xe5, 0xdb, 0x36, 0x1d, 0x5a, 0xcd, 0x2b, 0xa4, 0x1f, 0x4a, 0x80, 0x5e, 0x8b, 0x37, + 0xa9, 0x9a, 0x16, 0x13, 0x4d, 0x79, 0x31, 0x93, 0x39, 0x93, 0x9e, 0x80, 0x8c, 0xcc, 0x41, 0x78, + 0xb3, 0x7e, 0x1d, 0x96, 0xf7, 0x42, 0x7a, 0x5b, 0xbe, 0xfb, 0xc7, 0xcd, 0xbc, 0x49, 0x7f, 0x6a, + 0x5f, 0x0b, 0x7c, 0xdf, 0xff, 0xdc, 0x76, 0x03, 0xb3, 0x82, 0xaf, 0x57, 0xf0, 0xeb, 0x15, 0x1a, + 0x93, 0xba, 0x67, 0x2b, 0xee, 0xfb, 0x1a, 0x18, 0x6b, 0x60, 0x5c, 0x03, 0xe3, 0x06, 0x30, 0x36, + 0xc0, 0xa2, 0x3d, 0xd8, 0x0e, 0x18, 0x9f, 0x04, 0xc3, 0x97, 0xa0, 0x48, 0x42, 0x14, 0xf9, 0xd9, + 0xee, 0x1b, 0x78, 0x30, 0xd0, 0xb4, 0xfe, 0x5d, 0xe1, 0x65, 0xb8, 0xe6, 0x07, 0x03, 0x23, 0x30, + 0xb9, 0x5e, 0x7e, 0x80, 0x8e, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0xea, 0x31, 0xe6, 0x39, 0x23, + 0x05, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + CommunityPoolAssetBalances(ctx context.Context, in *CommunityPoolAssetBalancesRequest, opts ...grpc.CallOption) (QueryService_CommunityPoolAssetBalancesClient, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) CommunityPoolAssetBalances(ctx context.Context, in *CommunityPoolAssetBalancesRequest, opts ...grpc.CallOption) (QueryService_CommunityPoolAssetBalancesClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.core.component.community_pool.v1alpha1.QueryService/CommunityPoolAssetBalances", opts...) + if err != nil { + return nil, err + } + x := &queryServiceCommunityPoolAssetBalancesClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_CommunityPoolAssetBalancesClient interface { + Recv() (*CommunityPoolAssetBalancesResponse, error) + grpc.ClientStream +} + +type queryServiceCommunityPoolAssetBalancesClient struct { + grpc.ClientStream +} + +func (x *queryServiceCommunityPoolAssetBalancesClient) Recv() (*CommunityPoolAssetBalancesResponse, error) { + m := new(CommunityPoolAssetBalancesResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + CommunityPoolAssetBalances(*CommunityPoolAssetBalancesRequest, QueryService_CommunityPoolAssetBalancesServer) error +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) CommunityPoolAssetBalances(req *CommunityPoolAssetBalancesRequest, srv QueryService_CommunityPoolAssetBalancesServer) error { + return status.Errorf(codes.Unimplemented, "method CommunityPoolAssetBalances not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_CommunityPoolAssetBalances_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(CommunityPoolAssetBalancesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).CommunityPoolAssetBalances(m, &queryServiceCommunityPoolAssetBalancesServer{stream}) +} + +type QueryService_CommunityPoolAssetBalancesServer interface { + Send(*CommunityPoolAssetBalancesResponse) error + grpc.ServerStream +} + +type queryServiceCommunityPoolAssetBalancesServer struct { + grpc.ServerStream +} + +func (x *queryServiceCommunityPoolAssetBalancesServer) Send(m *CommunityPoolAssetBalancesResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.community_pool.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "CommunityPoolAssetBalances", + Handler: _QueryService_CommunityPoolAssetBalances_Handler, + ServerStreams: true, + }, + }, + Metadata: "penumbra/core/component/community_pool/v1alpha1/community_pool.proto", +} + +func (m *CommunityPoolParameters) 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 *CommunityPoolParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommunityPoolParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CommunityPoolSpendProposalsEnabled { + i-- + if m.CommunityPoolSpendProposalsEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CommunityPoolParams != nil { + { + size, err := m.CommunityPoolParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCommunityPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CommunityPoolAssetBalancesRequest) 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 *CommunityPoolAssetBalancesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommunityPoolAssetBalancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AssetIds) > 0 { + for iNdEx := len(m.AssetIds) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AssetIds[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCommunityPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintCommunityPool(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CommunityPoolAssetBalancesResponse) 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 *CommunityPoolAssetBalancesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommunityPoolAssetBalancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Balance != nil { + { + size, err := m.Balance.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCommunityPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintCommunityPool(dAtA []byte, offset int, v uint64) int { + offset -= sovCommunityPool(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *CommunityPoolParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CommunityPoolSpendProposalsEnabled { + n += 2 + } + return n +} + +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CommunityPoolParams != nil { + l = m.CommunityPoolParams.Size() + n += 1 + l + sovCommunityPool(uint64(l)) + } + return n +} + +func (m *CommunityPoolAssetBalancesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovCommunityPool(uint64(l)) + } + if len(m.AssetIds) > 0 { + for _, e := range m.AssetIds { + l = e.Size() + n += 1 + l + sovCommunityPool(uint64(l)) + } + } + return n +} + +func (m *CommunityPoolAssetBalancesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Balance != nil { + l = m.Balance.Size() + n += 1 + l + sovCommunityPool(uint64(l)) + } + return n +} + +func sovCommunityPool(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozCommunityPool(x uint64) (n int) { + return sovCommunityPool(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *CommunityPoolParameters) 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 ErrIntOverflowCommunityPool + } + 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: CommunityPoolParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommunityPoolParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolSpendProposalsEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommunityPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CommunityPoolSpendProposalsEnabled = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipCommunityPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCommunityPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent) 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 ErrIntOverflowCommunityPool + } + 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: GenesisContent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommunityPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCommunityPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCommunityPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CommunityPoolParams == nil { + m.CommunityPoolParams = &CommunityPoolParameters{} + } + if err := m.CommunityPoolParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCommunityPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCommunityPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommunityPoolAssetBalancesRequest) 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 ErrIntOverflowCommunityPool + } + 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: CommunityPoolAssetBalancesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommunityPoolAssetBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommunityPool + } + 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 ErrInvalidLengthCommunityPool + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommunityPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetIds", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommunityPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCommunityPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCommunityPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AssetIds = append(m.AssetIds, &v1alpha1.AssetId{}) + if err := m.AssetIds[len(m.AssetIds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCommunityPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCommunityPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommunityPoolAssetBalancesResponse) 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 ErrIntOverflowCommunityPool + } + 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: CommunityPoolAssetBalancesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommunityPoolAssetBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommunityPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCommunityPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCommunityPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Balance == nil { + m.Balance = &v1alpha1.Value{} + } + if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCommunityPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCommunityPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCommunityPool(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, ErrIntOverflowCommunityPool + } + 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, ErrIntOverflowCommunityPool + } + 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, ErrIntOverflowCommunityPool + } + 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, ErrInvalidLengthCommunityPool + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupCommunityPool + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthCommunityPool + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthCommunityPool = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCommunityPool = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupCommunityPool = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/component/compact_block/v1alpha1/compact_block.pb.go b/relayer/chains/penumbra/core/component/compact_block/v1alpha1/compact_block.pb.go new file mode 100644 index 000000000..d2cc727c2 --- /dev/null +++ b/relayer/chains/penumbra/core/component/compact_block/v1alpha1/compact_block.pb.go @@ -0,0 +1,2460 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/compact_block/v1alpha1/compact_block.proto + +package compact_blockv1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/chain/v1alpha1" + v1alpha13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/dex/v1alpha1" + v1alpha14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1alpha1" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1alpha1" + v1alpha15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +// Contains the minimum data needed to update client state. +type CompactBlock struct { + Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` + // State payloads describing new state fragments. + StatePayloads []*StatePayload `protobuf:"bytes,2,rep,name=state_payloads,json=statePayloads,proto3" json:"state_payloads,omitempty"` + // Nullifiers identifying spent notes. + Nullifiers []*v1alpha1.Nullifier `protobuf:"bytes,3,rep,name=nullifiers,proto3" json:"nullifiers,omitempty"` + // The block root of this block. + BlockRoot *v1alpha11.MerkleRoot `protobuf:"bytes,4,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty"` + // The epoch root of this epoch (only present when the block is the last in an epoch). + EpochRoot *v1alpha11.MerkleRoot `protobuf:"bytes,17,opt,name=epoch_root,json=epochRoot,proto3" json:"epoch_root,omitempty"` + // If a proposal started voting in this block, this is set to `true`. + ProposalStarted bool `protobuf:"varint,20,opt,name=proposal_started,json=proposalStarted,proto3" json:"proposal_started,omitempty"` + // Latest Fuzzy Message Detection parameters. + FmdParameters *v1alpha12.FmdParameters `protobuf:"bytes,100,opt,name=fmd_parameters,json=fmdParameters,proto3" json:"fmd_parameters,omitempty"` + // Price data for swaps executed in this block. + SwapOutputs []*v1alpha13.BatchSwapOutputData `protobuf:"bytes,5,rep,name=swap_outputs,json=swapOutputs,proto3" json:"swap_outputs,omitempty"` + // Indicates updated app parameters. + AppParametersUpdated bool `protobuf:"varint,6,opt,name=app_parameters_updated,json=appParametersUpdated,proto3" json:"app_parameters_updated,omitempty"` + // Updated gas prices, if they have changed. + GasPrices *v1alpha14.GasPrices `protobuf:"bytes,7,opt,name=gas_prices,json=gasPrices,proto3" json:"gas_prices,omitempty"` +} + +func (m *CompactBlock) Reset() { *m = CompactBlock{} } +func (m *CompactBlock) String() string { return proto.CompactTextString(m) } +func (*CompactBlock) ProtoMessage() {} +func (*CompactBlock) Descriptor() ([]byte, []int) { + return fileDescriptor_7db33c115ee8eed4, []int{0} +} +func (m *CompactBlock) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CompactBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CompactBlock.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 *CompactBlock) XXX_Merge(src proto.Message) { + xxx_messageInfo_CompactBlock.Merge(m, src) +} +func (m *CompactBlock) XXX_Size() int { + return m.Size() +} +func (m *CompactBlock) XXX_DiscardUnknown() { + xxx_messageInfo_CompactBlock.DiscardUnknown(m) +} + +var xxx_messageInfo_CompactBlock proto.InternalMessageInfo + +func (m *CompactBlock) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *CompactBlock) GetStatePayloads() []*StatePayload { + if m != nil { + return m.StatePayloads + } + return nil +} + +func (m *CompactBlock) GetNullifiers() []*v1alpha1.Nullifier { + if m != nil { + return m.Nullifiers + } + return nil +} + +func (m *CompactBlock) GetBlockRoot() *v1alpha11.MerkleRoot { + if m != nil { + return m.BlockRoot + } + return nil +} + +func (m *CompactBlock) GetEpochRoot() *v1alpha11.MerkleRoot { + if m != nil { + return m.EpochRoot + } + return nil +} + +func (m *CompactBlock) GetProposalStarted() bool { + if m != nil { + return m.ProposalStarted + } + return false +} + +func (m *CompactBlock) GetFmdParameters() *v1alpha12.FmdParameters { + if m != nil { + return m.FmdParameters + } + return nil +} + +func (m *CompactBlock) GetSwapOutputs() []*v1alpha13.BatchSwapOutputData { + if m != nil { + return m.SwapOutputs + } + return nil +} + +func (m *CompactBlock) GetAppParametersUpdated() bool { + if m != nil { + return m.AppParametersUpdated + } + return false +} + +func (m *CompactBlock) GetGasPrices() *v1alpha14.GasPrices { + if m != nil { + return m.GasPrices + } + return nil +} + +// An encrypted payload, corresponding to a single commitment in the state commitment tree. +type StatePayload struct { + // The source of the payload, if known. + Source *v1alpha1.CommitmentSource `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"` + // The state payload itself. + // + // Types that are valid to be assigned to StatePayload: + // *StatePayload_RolledUp_ + // *StatePayload_Note_ + // *StatePayload_Swap_ + StatePayload isStatePayload_StatePayload `protobuf_oneof:"state_payload"` +} + +func (m *StatePayload) Reset() { *m = StatePayload{} } +func (m *StatePayload) String() string { return proto.CompactTextString(m) } +func (*StatePayload) ProtoMessage() {} +func (*StatePayload) Descriptor() ([]byte, []int) { + return fileDescriptor_7db33c115ee8eed4, []int{1} +} +func (m *StatePayload) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StatePayload.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 *StatePayload) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatePayload.Merge(m, src) +} +func (m *StatePayload) XXX_Size() int { + return m.Size() +} +func (m *StatePayload) XXX_DiscardUnknown() { + xxx_messageInfo_StatePayload.DiscardUnknown(m) +} + +var xxx_messageInfo_StatePayload proto.InternalMessageInfo + +type isStatePayload_StatePayload interface { + isStatePayload_StatePayload() + MarshalTo([]byte) (int, error) + Size() int +} + +type StatePayload_RolledUp_ struct { + RolledUp *StatePayload_RolledUp `protobuf:"bytes,2,opt,name=rolled_up,json=rolledUp,proto3,oneof" json:"rolled_up,omitempty"` +} +type StatePayload_Note_ struct { + Note *StatePayload_Note `protobuf:"bytes,3,opt,name=note,proto3,oneof" json:"note,omitempty"` +} +type StatePayload_Swap_ struct { + Swap *StatePayload_Swap `protobuf:"bytes,4,opt,name=swap,proto3,oneof" json:"swap,omitempty"` +} + +func (*StatePayload_RolledUp_) isStatePayload_StatePayload() {} +func (*StatePayload_Note_) isStatePayload_StatePayload() {} +func (*StatePayload_Swap_) isStatePayload_StatePayload() {} + +func (m *StatePayload) GetStatePayload() isStatePayload_StatePayload { + if m != nil { + return m.StatePayload + } + return nil +} + +func (m *StatePayload) GetSource() *v1alpha1.CommitmentSource { + if m != nil { + return m.Source + } + return nil +} + +func (m *StatePayload) GetRolledUp() *StatePayload_RolledUp { + if x, ok := m.GetStatePayload().(*StatePayload_RolledUp_); ok { + return x.RolledUp + } + return nil +} + +func (m *StatePayload) GetNote() *StatePayload_Note { + if x, ok := m.GetStatePayload().(*StatePayload_Note_); ok { + return x.Note + } + return nil +} + +func (m *StatePayload) GetSwap() *StatePayload_Swap { + if x, ok := m.GetStatePayload().(*StatePayload_Swap_); ok { + return x.Swap + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*StatePayload) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*StatePayload_RolledUp_)(nil), + (*StatePayload_Note_)(nil), + (*StatePayload_Swap_)(nil), + } +} + +type StatePayload_RolledUp struct { + Commitment *v1alpha11.StateCommitment `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"` +} + +func (m *StatePayload_RolledUp) Reset() { *m = StatePayload_RolledUp{} } +func (m *StatePayload_RolledUp) String() string { return proto.CompactTextString(m) } +func (*StatePayload_RolledUp) ProtoMessage() {} +func (*StatePayload_RolledUp) Descriptor() ([]byte, []int) { + return fileDescriptor_7db33c115ee8eed4, []int{1, 0} +} +func (m *StatePayload_RolledUp) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatePayload_RolledUp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StatePayload_RolledUp.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 *StatePayload_RolledUp) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatePayload_RolledUp.Merge(m, src) +} +func (m *StatePayload_RolledUp) XXX_Size() int { + return m.Size() +} +func (m *StatePayload_RolledUp) XXX_DiscardUnknown() { + xxx_messageInfo_StatePayload_RolledUp.DiscardUnknown(m) +} + +var xxx_messageInfo_StatePayload_RolledUp proto.InternalMessageInfo + +func (m *StatePayload_RolledUp) GetCommitment() *v1alpha11.StateCommitment { + if m != nil { + return m.Commitment + } + return nil +} + +type StatePayload_Note struct { + Note *v1alpha15.NotePayload `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` +} + +func (m *StatePayload_Note) Reset() { *m = StatePayload_Note{} } +func (m *StatePayload_Note) String() string { return proto.CompactTextString(m) } +func (*StatePayload_Note) ProtoMessage() {} +func (*StatePayload_Note) Descriptor() ([]byte, []int) { + return fileDescriptor_7db33c115ee8eed4, []int{1, 1} +} +func (m *StatePayload_Note) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatePayload_Note) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StatePayload_Note.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 *StatePayload_Note) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatePayload_Note.Merge(m, src) +} +func (m *StatePayload_Note) XXX_Size() int { + return m.Size() +} +func (m *StatePayload_Note) XXX_DiscardUnknown() { + xxx_messageInfo_StatePayload_Note.DiscardUnknown(m) +} + +var xxx_messageInfo_StatePayload_Note proto.InternalMessageInfo + +func (m *StatePayload_Note) GetNote() *v1alpha15.NotePayload { + if m != nil { + return m.Note + } + return nil +} + +type StatePayload_Swap struct { + Swap *v1alpha13.SwapPayload `protobuf:"bytes,2,opt,name=swap,proto3" json:"swap,omitempty"` +} + +func (m *StatePayload_Swap) Reset() { *m = StatePayload_Swap{} } +func (m *StatePayload_Swap) String() string { return proto.CompactTextString(m) } +func (*StatePayload_Swap) ProtoMessage() {} +func (*StatePayload_Swap) Descriptor() ([]byte, []int) { + return fileDescriptor_7db33c115ee8eed4, []int{1, 2} +} +func (m *StatePayload_Swap) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatePayload_Swap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StatePayload_Swap.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 *StatePayload_Swap) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatePayload_Swap.Merge(m, src) +} +func (m *StatePayload_Swap) XXX_Size() int { + return m.Size() +} +func (m *StatePayload_Swap) XXX_DiscardUnknown() { + xxx_messageInfo_StatePayload_Swap.DiscardUnknown(m) +} + +var xxx_messageInfo_StatePayload_Swap proto.InternalMessageInfo + +func (m *StatePayload_Swap) GetSwap() *v1alpha13.SwapPayload { + if m != nil { + return m.Swap + } + return nil +} + +// Requests a range of compact block data. +type CompactBlockRangeRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The start height of the range. + StartHeight uint64 `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` + // The end height of the range, defaults to the latest block height. + EndHeight uint64 `protobuf:"varint,3,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"` + // If set, keeps the connection alive past `end_height`, + // streaming new compact blocks as they are created. + KeepAlive bool `protobuf:"varint,4,opt,name=keep_alive,json=keepAlive,proto3" json:"keep_alive,omitempty"` +} + +func (m *CompactBlockRangeRequest) Reset() { *m = CompactBlockRangeRequest{} } +func (m *CompactBlockRangeRequest) String() string { return proto.CompactTextString(m) } +func (*CompactBlockRangeRequest) ProtoMessage() {} +func (*CompactBlockRangeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7db33c115ee8eed4, []int{2} +} +func (m *CompactBlockRangeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CompactBlockRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CompactBlockRangeRequest.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 *CompactBlockRangeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CompactBlockRangeRequest.Merge(m, src) +} +func (m *CompactBlockRangeRequest) XXX_Size() int { + return m.Size() +} +func (m *CompactBlockRangeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CompactBlockRangeRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_CompactBlockRangeRequest proto.InternalMessageInfo + +func (m *CompactBlockRangeRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *CompactBlockRangeRequest) GetStartHeight() uint64 { + if m != nil { + return m.StartHeight + } + return 0 +} + +func (m *CompactBlockRangeRequest) GetEndHeight() uint64 { + if m != nil { + return m.EndHeight + } + return 0 +} + +func (m *CompactBlockRangeRequest) GetKeepAlive() bool { + if m != nil { + return m.KeepAlive + } + return false +} + +type CompactBlockRangeResponse struct { + CompactBlock *CompactBlock `protobuf:"bytes,1,opt,name=compact_block,json=compactBlock,proto3" json:"compact_block,omitempty"` +} + +func (m *CompactBlockRangeResponse) Reset() { *m = CompactBlockRangeResponse{} } +func (m *CompactBlockRangeResponse) String() string { return proto.CompactTextString(m) } +func (*CompactBlockRangeResponse) ProtoMessage() {} +func (*CompactBlockRangeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7db33c115ee8eed4, []int{3} +} +func (m *CompactBlockRangeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CompactBlockRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CompactBlockRangeResponse.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 *CompactBlockRangeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CompactBlockRangeResponse.Merge(m, src) +} +func (m *CompactBlockRangeResponse) XXX_Size() int { + return m.Size() +} +func (m *CompactBlockRangeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CompactBlockRangeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CompactBlockRangeResponse proto.InternalMessageInfo + +func (m *CompactBlockRangeResponse) GetCompactBlock() *CompactBlock { + if m != nil { + return m.CompactBlock + } + return nil +} + +func init() { + proto.RegisterType((*CompactBlock)(nil), "penumbra.core.component.compact_block.v1alpha1.CompactBlock") + proto.RegisterType((*StatePayload)(nil), "penumbra.core.component.compact_block.v1alpha1.StatePayload") + proto.RegisterType((*StatePayload_RolledUp)(nil), "penumbra.core.component.compact_block.v1alpha1.StatePayload.RolledUp") + proto.RegisterType((*StatePayload_Note)(nil), "penumbra.core.component.compact_block.v1alpha1.StatePayload.Note") + proto.RegisterType((*StatePayload_Swap)(nil), "penumbra.core.component.compact_block.v1alpha1.StatePayload.Swap") + proto.RegisterType((*CompactBlockRangeRequest)(nil), "penumbra.core.component.compact_block.v1alpha1.CompactBlockRangeRequest") + proto.RegisterType((*CompactBlockRangeResponse)(nil), "penumbra.core.component.compact_block.v1alpha1.CompactBlockRangeResponse") +} + +func init() { + proto.RegisterFile("penumbra/core/component/compact_block/v1alpha1/compact_block.proto", fileDescriptor_7db33c115ee8eed4) +} + +var fileDescriptor_7db33c115ee8eed4 = []byte{ + // 977 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x4d, 0x6f, 0xdb, 0x36, + 0x18, 0xc7, 0x23, 0xdb, 0x49, 0x6d, 0xda, 0x69, 0x57, 0xa2, 0x28, 0x54, 0x03, 0x33, 0xb2, 0x1c, + 0x06, 0xef, 0x50, 0x69, 0xf1, 0x5e, 0x80, 0xa6, 0xbb, 0xd4, 0x5e, 0x97, 0xf4, 0x90, 0xc4, 0x93, + 0xd1, 0x15, 0x1b, 0x0c, 0x08, 0x8c, 0xf4, 0xd8, 0x16, 0x22, 0x89, 0x1c, 0x49, 0xa5, 0xcd, 0x65, + 0x1f, 0x60, 0xa7, 0x9d, 0xf6, 0x01, 0x76, 0xcc, 0x57, 0xd8, 0x17, 0x18, 0x76, 0xea, 0x71, 0xc0, + 0x2e, 0x43, 0x72, 0xdb, 0xa7, 0x18, 0x48, 0xbd, 0x1a, 0x9b, 0xd7, 0x1a, 0xe9, 0x25, 0x20, 0xe9, + 0xe7, 0xff, 0x7b, 0x1e, 0xfe, 0x49, 0x3e, 0x11, 0x1a, 0x32, 0x88, 0x93, 0xe8, 0x94, 0x13, 0xdb, + 0xa3, 0x1c, 0x6c, 0x8f, 0x46, 0x8c, 0xc6, 0x10, 0x4b, 0x3d, 0x22, 0x9e, 0x74, 0x4f, 0x43, 0xea, + 0x9d, 0xd9, 0xe7, 0x7b, 0x24, 0x64, 0x0b, 0xb2, 0xb7, 0xbc, 0x6c, 0x31, 0x4e, 0x25, 0xc5, 0x56, + 0xce, 0xb0, 0x14, 0xc3, 0x2a, 0x18, 0xd6, 0x72, 0x70, 0xce, 0xe8, 0x0e, 0x56, 0xe6, 0x5c, 0x90, + 0x20, 0xae, 0xe4, 0x52, 0xd3, 0x34, 0x47, 0xd7, 0x5a, 0xa5, 0xf1, 0xe1, 0x55, 0xa9, 0xf0, 0xe1, + 0xd5, 0x9b, 0xe2, 0x67, 0x00, 0x65, 0xfc, 0x0c, 0xe0, 0x4d, 0xf1, 0xc2, 0x93, 0x65, 0xbc, 0xf0, + 0x64, 0x16, 0xbf, 0xd2, 0x37, 0xb1, 0x08, 0x20, 0xf4, 0xc1, 0x77, 0x19, 0xa5, 0x61, 0x45, 0x59, + 0x5d, 0xce, 0x18, 0x1f, 0x96, 0x0c, 0x7e, 0xc1, 0x24, 0xb5, 0x65, 0x35, 0x97, 0xcc, 0x73, 0xed, + 0xfe, 0xb9, 0x89, 0x3a, 0xa3, 0xd4, 0xca, 0xa1, 0x72, 0x12, 0xdf, 0x47, 0x5b, 0x0b, 0x08, 0xe6, + 0x0b, 0x69, 0x1a, 0x3b, 0x46, 0xbf, 0xe1, 0x64, 0x33, 0xec, 0xa1, 0xdb, 0x42, 0x12, 0x09, 0x2e, + 0x23, 0x17, 0x21, 0x25, 0xbe, 0x30, 0x6b, 0x3b, 0xf5, 0x7e, 0x7b, 0xf0, 0xc5, 0x9a, 0x27, 0x64, + 0x4d, 0x14, 0x65, 0x9c, 0x42, 0x9c, 0x6d, 0x51, 0x99, 0x09, 0x7c, 0x82, 0x50, 0x9c, 0x84, 0x61, + 0x30, 0x0b, 0x80, 0x0b, 0xb3, 0xae, 0x13, 0xd8, 0x2b, 0x13, 0x28, 0xc7, 0x0a, 0xec, 0x71, 0xae, + 0x73, 0x2a, 0x08, 0x7c, 0x80, 0x90, 0x4e, 0xef, 0x72, 0x4a, 0xa5, 0xd9, 0xd8, 0x31, 0xfa, 0xed, + 0x41, 0xbf, 0x02, 0xd4, 0xde, 0x58, 0xb2, 0x0a, 0x3a, 0x02, 0x7e, 0x16, 0x82, 0x43, 0xa9, 0x74, + 0x5a, 0x5a, 0xab, 0x86, 0x0a, 0x04, 0x8c, 0x7a, 0x8b, 0x14, 0x74, 0x77, 0x5d, 0x90, 0xd6, 0x6a, + 0xd0, 0x47, 0xe8, 0x3d, 0xc6, 0x29, 0xa3, 0x82, 0x84, 0xae, 0x90, 0x84, 0x4b, 0xf0, 0xcd, 0x7b, + 0x3b, 0x46, 0xbf, 0xe9, 0xdc, 0xc9, 0xd7, 0x27, 0xe9, 0x32, 0x9e, 0xa2, 0xdb, 0xb3, 0xc8, 0x77, + 0x19, 0xe1, 0x24, 0x02, 0xa9, 0x1c, 0xf1, 0x75, 0xde, 0xcf, 0x56, 0x5b, 0xae, 0x6f, 0x75, 0x51, + 0xc1, 0x57, 0x91, 0x3f, 0x2e, 0xc4, 0xce, 0xf6, 0xac, 0x3a, 0xc5, 0x53, 0xd4, 0x11, 0x2f, 0x09, + 0x73, 0x69, 0x22, 0x59, 0x22, 0x85, 0xb9, 0xa9, 0xdd, 0x7e, 0xb4, 0x92, 0xad, 0xee, 0x7f, 0x41, + 0x1e, 0x12, 0xe9, 0x2d, 0x26, 0x2f, 0x09, 0x3b, 0xd1, 0xea, 0x2f, 0x89, 0x24, 0x4e, 0x5b, 0x14, + 0x73, 0x81, 0x3f, 0x45, 0xf7, 0x09, 0x63, 0x95, 0xda, 0xdd, 0x84, 0xf9, 0x44, 0x6d, 0x76, 0x4b, + 0x6f, 0xf6, 0x1e, 0x61, 0xac, 0x2c, 0xe6, 0x79, 0xfa, 0x1b, 0x3e, 0x46, 0x68, 0x4e, 0x84, 0xcb, + 0x78, 0xe0, 0x81, 0x30, 0x6f, 0xe9, 0xdd, 0xae, 0x3e, 0x7f, 0xf5, 0xc2, 0x8a, 0x8a, 0x0e, 0x88, + 0x18, 0x6b, 0x99, 0xd3, 0x9a, 0xe7, 0xc3, 0xdd, 0x1f, 0x37, 0x51, 0xa7, 0x7a, 0xdf, 0xf0, 0x31, + 0xda, 0x12, 0x34, 0xe1, 0x1e, 0xe8, 0xdb, 0xdd, 0x1e, 0x7c, 0xfe, 0x76, 0x97, 0x6b, 0x44, 0xa3, + 0x28, 0x90, 0x11, 0xc4, 0x72, 0xa2, 0xd5, 0x4e, 0x46, 0xc1, 0x3e, 0x6a, 0x71, 0x1a, 0x86, 0xe0, + 0xbb, 0x09, 0x33, 0x6b, 0x1a, 0xf9, 0xf4, 0x26, 0x0f, 0xc2, 0x72, 0x34, 0xed, 0x39, 0x3b, 0xdc, + 0x70, 0x9a, 0x3c, 0x1b, 0xe3, 0x17, 0xa8, 0x11, 0x53, 0x09, 0x66, 0x5d, 0x27, 0x78, 0x72, 0xa3, + 0x04, 0xc7, 0x54, 0xc2, 0xe1, 0x86, 0xa3, 0x81, 0x0a, 0xac, 0x0e, 0x2d, 0x7b, 0x18, 0x37, 0x03, + 0xab, 0xdb, 0xa0, 0xc0, 0x0a, 0xd8, 0xfd, 0x16, 0x35, 0xf3, 0x9d, 0xe0, 0x23, 0x84, 0xbc, 0xc2, + 0xbf, 0xcc, 0xf7, 0x87, 0xff, 0xff, 0x74, 0x34, 0xb8, 0x34, 0xdd, 0xa9, 0x00, 0xba, 0x2f, 0x50, + 0x43, 0xed, 0x01, 0x9f, 0x64, 0xa6, 0xa4, 0xae, 0x3f, 0x5e, 0x7d, 0x90, 0x4b, 0xdd, 0xb1, 0xec, + 0x17, 0xb4, 0xec, 0x42, 0x1a, 0xd4, 0x3d, 0x42, 0x0d, 0xb5, 0x07, 0xfc, 0x34, 0x33, 0x25, 0x05, + 0xef, 0xbd, 0xdd, 0x83, 0x50, 0xca, 0x02, 0xa7, 0xe4, 0xc3, 0x3b, 0x68, 0x7b, 0xa9, 0x61, 0xee, + 0xfe, 0x6c, 0x20, 0xb3, 0xda, 0x6a, 0x1d, 0x12, 0xcf, 0xc1, 0x81, 0xef, 0x13, 0x10, 0x12, 0x3f, + 0x40, 0x4d, 0xfd, 0x78, 0xdd, 0xc0, 0xd7, 0x16, 0xb5, 0x9c, 0x5b, 0x7a, 0xfe, 0xcc, 0xc7, 0x1f, + 0xa0, 0x8e, 0x6e, 0x14, 0x6e, 0xd6, 0x97, 0x6b, 0xba, 0x2f, 0xb7, 0xf5, 0xda, 0x61, 0xda, 0x9c, + 0xdf, 0x47, 0x08, 0x62, 0x3f, 0x0f, 0xa8, 0xeb, 0x80, 0x16, 0xc4, 0x7e, 0xf9, 0xf3, 0x19, 0x00, + 0x73, 0x49, 0x18, 0x9c, 0x83, 0x3e, 0xec, 0xa6, 0xd3, 0x52, 0x2b, 0x4f, 0xd4, 0xc2, 0xee, 0x0f, + 0xe8, 0xc1, 0x7f, 0xd4, 0x25, 0x18, 0x8d, 0x05, 0x60, 0x82, 0xb6, 0x97, 0x4e, 0x3f, 0x3b, 0xc0, + 0xb5, 0xdb, 0xfe, 0x52, 0x86, 0x8e, 0x57, 0x99, 0x0d, 0x7e, 0x35, 0x50, 0xe7, 0xeb, 0x04, 0xf8, + 0xc5, 0x04, 0xf8, 0x79, 0xe0, 0x01, 0xbe, 0x34, 0xd0, 0xdd, 0x7f, 0x55, 0x84, 0x0f, 0x6f, 0x94, + 0xb2, 0x62, 0x76, 0xf7, 0xd9, 0x3b, 0x20, 0xa5, 0xf6, 0x7c, 0x6c, 0x0c, 0x2f, 0xeb, 0xbf, 0x5d, + 0xf5, 0x8c, 0xd7, 0x57, 0x3d, 0xe3, 0xaf, 0xab, 0x9e, 0xf1, 0xd3, 0x75, 0x6f, 0xe3, 0xf5, 0x75, + 0x6f, 0xe3, 0x8f, 0xeb, 0xde, 0x06, 0x1a, 0x78, 0x34, 0x5a, 0x33, 0xd5, 0x70, 0x69, 0xe3, 0x63, + 0xf5, 0x3f, 0x7a, 0x6c, 0x7c, 0xc7, 0xe6, 0x81, 0x5c, 0x24, 0xa7, 0x4a, 0x63, 0x7b, 0x54, 0x44, + 0x54, 0xd8, 0x1c, 0x42, 0x72, 0x01, 0xdc, 0x3e, 0x1f, 0x14, 0x43, 0x7d, 0x61, 0x84, 0xbd, 0xde, + 0x57, 0xd7, 0xe3, 0xa5, 0xe5, 0x7c, 0xf5, 0x97, 0x5a, 0x63, 0x3c, 0x1a, 0x8d, 0x2e, 0x6b, 0x0f, + 0xc7, 0x79, 0xf9, 0x23, 0x55, 0xfe, 0xa8, 0x28, 0xbf, 0x5a, 0xa6, 0xf5, 0x4d, 0x26, 0xfb, 0xbd, + 0x8c, 0x9f, 0xaa, 0xf8, 0x69, 0x11, 0x3f, 0xad, 0xc6, 0x4f, 0xf3, 0xf8, 0xab, 0xda, 0xa3, 0xb5, + 0xe2, 0xa7, 0x07, 0xe3, 0xe1, 0x11, 0x48, 0xe2, 0x13, 0x49, 0xfe, 0xae, 0xed, 0xe5, 0xda, 0xfd, + 0x7d, 0x25, 0x56, 0x7f, 0x33, 0x75, 0x3a, 0xcc, 0xe5, 0xfb, 0xfb, 0xb9, 0xfe, 0x74, 0x4b, 0x7f, + 0xf5, 0x7c, 0xf2, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5b, 0x7c, 0x77, 0xc8, 0x9b, 0x0a, 0x00, + 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + // Returns a stream of `CompactBlockRangeResponse`s. + CompactBlockRange(ctx context.Context, in *CompactBlockRangeRequest, opts ...grpc.CallOption) (QueryService_CompactBlockRangeClient, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) CompactBlockRange(ctx context.Context, in *CompactBlockRangeRequest, opts ...grpc.CallOption) (QueryService_CompactBlockRangeClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.core.component.compact_block.v1alpha1.QueryService/CompactBlockRange", opts...) + if err != nil { + return nil, err + } + x := &queryServiceCompactBlockRangeClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_CompactBlockRangeClient interface { + Recv() (*CompactBlockRangeResponse, error) + grpc.ClientStream +} + +type queryServiceCompactBlockRangeClient struct { + grpc.ClientStream +} + +func (x *queryServiceCompactBlockRangeClient) Recv() (*CompactBlockRangeResponse, error) { + m := new(CompactBlockRangeResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + // Returns a stream of `CompactBlockRangeResponse`s. + CompactBlockRange(*CompactBlockRangeRequest, QueryService_CompactBlockRangeServer) error +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) CompactBlockRange(req *CompactBlockRangeRequest, srv QueryService_CompactBlockRangeServer) error { + return status.Errorf(codes.Unimplemented, "method CompactBlockRange not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_CompactBlockRange_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(CompactBlockRangeRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).CompactBlockRange(m, &queryServiceCompactBlockRangeServer{stream}) +} + +type QueryService_CompactBlockRangeServer interface { + Send(*CompactBlockRangeResponse) error + grpc.ServerStream +} + +type queryServiceCompactBlockRangeServer struct { + grpc.ServerStream +} + +func (x *queryServiceCompactBlockRangeServer) Send(m *CompactBlockRangeResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.compact_block.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "CompactBlockRange", + Handler: _QueryService_CompactBlockRange_Handler, + ServerStreams: true, + }, + }, + Metadata: "penumbra/core/component/compact_block/v1alpha1/compact_block.proto", +} + +func (m *CompactBlock) 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 *CompactBlock) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CompactBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.FmdParameters != nil { + { + size, err := m.FmdParameters.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xa2 + } + if m.ProposalStarted { + i-- + if m.ProposalStarted { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa0 + } + if m.EpochRoot != nil { + { + size, err := m.EpochRoot.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if m.GasPrices != nil { + { + size, err := m.GasPrices.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.AppParametersUpdated { + i-- + if m.AppParametersUpdated { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if len(m.SwapOutputs) > 0 { + for iNdEx := len(m.SwapOutputs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SwapOutputs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if m.BlockRoot != nil { + { + size, err := m.BlockRoot.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if len(m.Nullifiers) > 0 { + for iNdEx := len(m.Nullifiers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Nullifiers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.StatePayloads) > 0 { + for iNdEx := len(m.StatePayloads) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.StatePayloads[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.Height != 0 { + i = encodeVarintCompactBlock(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *StatePayload) 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 *StatePayload) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatePayload) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.StatePayload != nil { + { + size := m.StatePayload.Size() + i -= size + if _, err := m.StatePayload.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + if m.Source != nil { + { + size, err := m.Source.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StatePayload_RolledUp_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatePayload_RolledUp_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.RolledUp != nil { + { + size, err := m.RolledUp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *StatePayload_Note_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatePayload_Note_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Note != nil { + { + size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *StatePayload_Swap_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatePayload_Swap_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Swap != nil { + { + size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *StatePayload_RolledUp) 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 *StatePayload_RolledUp) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatePayload_RolledUp) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Commitment != nil { + { + size, err := m.Commitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StatePayload_Note) 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 *StatePayload_Note) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatePayload_Note) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Note != nil { + { + size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *StatePayload_Swap) 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 *StatePayload_Swap) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatePayload_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Swap != nil { + { + size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CompactBlockRangeRequest) 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 *CompactBlockRangeRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CompactBlockRangeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.KeepAlive { + i-- + if m.KeepAlive { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.EndHeight != 0 { + i = encodeVarintCompactBlock(dAtA, i, uint64(m.EndHeight)) + i-- + dAtA[i] = 0x18 + } + if m.StartHeight != 0 { + i = encodeVarintCompactBlock(dAtA, i, uint64(m.StartHeight)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintCompactBlock(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CompactBlockRangeResponse) 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 *CompactBlockRangeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CompactBlockRangeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CompactBlock != nil { + { + size, err := m.CompactBlock.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCompactBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintCompactBlock(dAtA []byte, offset int, v uint64) int { + offset -= sovCompactBlock(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *CompactBlock) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovCompactBlock(uint64(m.Height)) + } + if len(m.StatePayloads) > 0 { + for _, e := range m.StatePayloads { + l = e.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + } + if len(m.Nullifiers) > 0 { + for _, e := range m.Nullifiers { + l = e.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + } + if m.BlockRoot != nil { + l = m.BlockRoot.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + if len(m.SwapOutputs) > 0 { + for _, e := range m.SwapOutputs { + l = e.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + } + if m.AppParametersUpdated { + n += 2 + } + if m.GasPrices != nil { + l = m.GasPrices.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + if m.EpochRoot != nil { + l = m.EpochRoot.Size() + n += 2 + l + sovCompactBlock(uint64(l)) + } + if m.ProposalStarted { + n += 3 + } + if m.FmdParameters != nil { + l = m.FmdParameters.Size() + n += 2 + l + sovCompactBlock(uint64(l)) + } + return n +} + +func (m *StatePayload) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != nil { + l = m.Source.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + if m.StatePayload != nil { + n += m.StatePayload.Size() + } + return n +} + +func (m *StatePayload_RolledUp_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RolledUp != nil { + l = m.RolledUp.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + return n +} +func (m *StatePayload_Note_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Note != nil { + l = m.Note.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + return n +} +func (m *StatePayload_Swap_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Swap != nil { + l = m.Swap.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + return n +} +func (m *StatePayload_RolledUp) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Commitment != nil { + l = m.Commitment.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + return n +} + +func (m *StatePayload_Note) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Note != nil { + l = m.Note.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + return n +} + +func (m *StatePayload_Swap) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Swap != nil { + l = m.Swap.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + return n +} + +func (m *CompactBlockRangeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovCompactBlock(uint64(l)) + } + if m.StartHeight != 0 { + n += 1 + sovCompactBlock(uint64(m.StartHeight)) + } + if m.EndHeight != 0 { + n += 1 + sovCompactBlock(uint64(m.EndHeight)) + } + if m.KeepAlive { + n += 2 + } + return n +} + +func (m *CompactBlockRangeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CompactBlock != nil { + l = m.CompactBlock.Size() + n += 1 + l + sovCompactBlock(uint64(l)) + } + return n +} + +func sovCompactBlock(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozCompactBlock(x uint64) (n int) { + return sovCompactBlock(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *CompactBlock) 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 ErrIntOverflowCompactBlock + } + 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: CompactBlock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CompactBlock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StatePayloads", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StatePayloads = append(m.StatePayloads, &StatePayload{}) + if err := m.StatePayloads[len(m.StatePayloads)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nullifiers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Nullifiers = append(m.Nullifiers, &v1alpha1.Nullifier{}) + if err := m.Nullifiers[len(m.Nullifiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockRoot == nil { + m.BlockRoot = &v1alpha11.MerkleRoot{} + } + if err := m.BlockRoot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapOutputs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SwapOutputs = append(m.SwapOutputs, &v1alpha13.BatchSwapOutputData{}) + if err := m.SwapOutputs[len(m.SwapOutputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppParametersUpdated", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AppParametersUpdated = bool(v != 0) + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasPrices", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasPrices == nil { + m.GasPrices = &v1alpha14.GasPrices{} + } + if err := m.GasPrices.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EpochRoot == nil { + m.EpochRoot = &v1alpha11.MerkleRoot{} + } + if err := m.EpochRoot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 20: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalStarted", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ProposalStarted = bool(v != 0) + case 100: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FmdParameters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FmdParameters == nil { + m.FmdParameters = &v1alpha12.FmdParameters{} + } + if err := m.FmdParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCompactBlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCompactBlock + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StatePayload) 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 ErrIntOverflowCompactBlock + } + 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: StatePayload: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatePayload: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = &v1alpha1.CommitmentSource{} + } + if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RolledUp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &StatePayload_RolledUp{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.StatePayload = &StatePayload_RolledUp_{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &StatePayload_Note{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.StatePayload = &StatePayload_Note_{v} + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &StatePayload_Swap{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.StatePayload = &StatePayload_Swap_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCompactBlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCompactBlock + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StatePayload_RolledUp) 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 ErrIntOverflowCompactBlock + } + 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: RolledUp: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RolledUp: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Commitment == nil { + m.Commitment = &v1alpha11.StateCommitment{} + } + if err := m.Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCompactBlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCompactBlock + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StatePayload_Note) 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 ErrIntOverflowCompactBlock + } + 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: Note: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Note: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Note == nil { + m.Note = &v1alpha15.NotePayload{} + } + if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCompactBlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCompactBlock + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StatePayload_Swap) 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 ErrIntOverflowCompactBlock + } + 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: Swap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Swap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Swap == nil { + m.Swap = &v1alpha13.SwapPayload{} + } + if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCompactBlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCompactBlock + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CompactBlockRangeRequest) 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 ErrIntOverflowCompactBlock + } + 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: CompactBlockRangeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CompactBlockRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + 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 ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType) + } + m.StartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndHeight", wireType) + } + m.EndHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeepAlive", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.KeepAlive = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipCompactBlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCompactBlock + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CompactBlockRangeResponse) 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 ErrIntOverflowCompactBlock + } + 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: CompactBlockRangeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CompactBlockRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CompactBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCompactBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCompactBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCompactBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CompactBlock == nil { + m.CompactBlock = &CompactBlock{} + } + if err := m.CompactBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCompactBlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCompactBlock + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCompactBlock(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, ErrIntOverflowCompactBlock + } + 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, ErrIntOverflowCompactBlock + } + 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, ErrIntOverflowCompactBlock + } + 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, ErrInvalidLengthCompactBlock + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupCompactBlock + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthCompactBlock + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthCompactBlock = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCompactBlock = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupCompactBlock = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/component/dao/v1alpha1/dao.pb.go b/relayer/chains/penumbra/core/component/dao/v1alpha1/dao.pb.go new file mode 100644 index 000000000..dcd66bfc2 --- /dev/null +++ b/relayer/chains/penumbra/core/component/dao/v1alpha1/dao.pb.go @@ -0,0 +1,1040 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/dao/v1alpha1/dao.proto + +package daov1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +// Dao parameter data. +type DaoParameters struct { + // Whether DAO spend proposals are enabled. + DaoSpendProposalsEnabled bool `protobuf:"varint,1,opt,name=dao_spend_proposals_enabled,json=daoSpendProposalsEnabled,proto3" json:"dao_spend_proposals_enabled,omitempty"` +} + +func (m *DaoParameters) Reset() { *m = DaoParameters{} } +func (m *DaoParameters) String() string { return proto.CompactTextString(m) } +func (*DaoParameters) ProtoMessage() {} +func (*DaoParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_a2476c8b34dca79f, []int{0} +} +func (m *DaoParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DaoParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DaoParameters.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 *DaoParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_DaoParameters.Merge(m, src) +} +func (m *DaoParameters) XXX_Size() int { + return m.Size() +} +func (m *DaoParameters) XXX_DiscardUnknown() { + xxx_messageInfo_DaoParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_DaoParameters proto.InternalMessageInfo + +func (m *DaoParameters) GetDaoSpendProposalsEnabled() bool { + if m != nil { + return m.DaoSpendProposalsEnabled + } + return false +} + +// Dao genesis state. +type GenesisContent struct { + // Dao parameters. + DaoParams *DaoParameters `protobuf:"bytes,1,opt,name=dao_params,json=daoParams,proto3" json:"dao_params,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_a2476c8b34dca79f, []int{1} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.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 *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetDaoParams() *DaoParameters { + if m != nil { + return m.DaoParams + } + return nil +} + +// Requests the list of all asset balances associated with the DAO. +type DaoAssetBalancesRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // (Optional): The specific asset balances to retrieve, if excluded all will be returned. + AssetIds []*v1alpha1.AssetId `protobuf:"bytes,2,rep,name=asset_ids,json=assetIds,proto3" json:"asset_ids,omitempty"` +} + +func (m *DaoAssetBalancesRequest) Reset() { *m = DaoAssetBalancesRequest{} } +func (m *DaoAssetBalancesRequest) String() string { return proto.CompactTextString(m) } +func (*DaoAssetBalancesRequest) ProtoMessage() {} +func (*DaoAssetBalancesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_a2476c8b34dca79f, []int{2} +} +func (m *DaoAssetBalancesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DaoAssetBalancesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DaoAssetBalancesRequest.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 *DaoAssetBalancesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DaoAssetBalancesRequest.Merge(m, src) +} +func (m *DaoAssetBalancesRequest) XXX_Size() int { + return m.Size() +} +func (m *DaoAssetBalancesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DaoAssetBalancesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DaoAssetBalancesRequest proto.InternalMessageInfo + +func (m *DaoAssetBalancesRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *DaoAssetBalancesRequest) GetAssetIds() []*v1alpha1.AssetId { + if m != nil { + return m.AssetIds + } + return nil +} + +// The DAO's balance of a single asset. +type DaoAssetBalancesResponse struct { + // The balance for a single asset. + Balance *v1alpha1.Value `protobuf:"bytes,1,opt,name=balance,proto3" json:"balance,omitempty"` +} + +func (m *DaoAssetBalancesResponse) Reset() { *m = DaoAssetBalancesResponse{} } +func (m *DaoAssetBalancesResponse) String() string { return proto.CompactTextString(m) } +func (*DaoAssetBalancesResponse) ProtoMessage() {} +func (*DaoAssetBalancesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a2476c8b34dca79f, []int{3} +} +func (m *DaoAssetBalancesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DaoAssetBalancesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DaoAssetBalancesResponse.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 *DaoAssetBalancesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DaoAssetBalancesResponse.Merge(m, src) +} +func (m *DaoAssetBalancesResponse) XXX_Size() int { + return m.Size() +} +func (m *DaoAssetBalancesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DaoAssetBalancesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DaoAssetBalancesResponse proto.InternalMessageInfo + +func (m *DaoAssetBalancesResponse) GetBalance() *v1alpha1.Value { + if m != nil { + return m.Balance + } + return nil +} + +func init() { + proto.RegisterType((*DaoParameters)(nil), "penumbra.core.component.dao.v1alpha1.DaoParameters") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.dao.v1alpha1.GenesisContent") + proto.RegisterType((*DaoAssetBalancesRequest)(nil), "penumbra.core.component.dao.v1alpha1.DaoAssetBalancesRequest") + proto.RegisterType((*DaoAssetBalancesResponse)(nil), "penumbra.core.component.dao.v1alpha1.DaoAssetBalancesResponse") +} + +func init() { + proto.RegisterFile("penumbra/core/component/dao/v1alpha1/dao.proto", fileDescriptor_a2476c8b34dca79f) +} + +var fileDescriptor_a2476c8b34dca79f = []byte{ + // 510 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0x41, 0x8b, 0xd3, 0x40, + 0x14, 0xc7, 0x37, 0x51, 0xdc, 0x76, 0x56, 0x45, 0x72, 0xb1, 0xae, 0x10, 0x96, 0xba, 0x42, 0x4f, + 0xc9, 0x6e, 0xf7, 0x16, 0xa9, 0x60, 0x1b, 0x59, 0xf6, 0xa0, 0xc4, 0x2c, 0x2c, 0x28, 0x81, 0xf2, + 0x9a, 0x79, 0xd8, 0x40, 0x3a, 0x2f, 0xce, 0x4c, 0x8b, 0xfb, 0x2d, 0x04, 0xbf, 0x81, 0x78, 0xf2, + 0x93, 0x88, 0xa7, 0x3d, 0x7a, 0x53, 0xda, 0x9b, 0x9f, 0x42, 0x26, 0x69, 0xba, 0xec, 0x2a, 0x12, + 0xbc, 0x84, 0x79, 0xc9, 0xef, 0xff, 0x7f, 0xff, 0x37, 0x93, 0x61, 0x5e, 0x81, 0x62, 0x3e, 0x9b, + 0x48, 0xf0, 0x53, 0x92, 0xe8, 0xa7, 0x34, 0x2b, 0x48, 0xa0, 0xd0, 0x3e, 0x07, 0xf2, 0x17, 0x87, + 0x90, 0x17, 0x53, 0x38, 0x34, 0x85, 0x57, 0x48, 0xd2, 0xe4, 0xec, 0xd7, 0xbc, 0x67, 0x78, 0x6f, + 0xc3, 0x7b, 0x06, 0xa9, 0xf9, 0xdd, 0xde, 0x55, 0x57, 0x50, 0x0a, 0xf5, 0xa5, 0x5b, 0x59, 0x56, + 0x7e, 0xdd, 0x97, 0xec, 0x4e, 0x08, 0x14, 0x81, 0x84, 0x19, 0x6a, 0x94, 0xca, 0x19, 0xb0, 0x87, + 0x1c, 0x68, 0xac, 0x0a, 0x14, 0x7c, 0x5c, 0x48, 0x2a, 0x48, 0x41, 0xae, 0xc6, 0x28, 0x60, 0x92, + 0x23, 0xef, 0x58, 0x7b, 0x56, 0xaf, 0x15, 0x77, 0x38, 0xd0, 0xa9, 0x21, 0xa2, 0x1a, 0x78, 0x5e, + 0x7d, 0xef, 0x72, 0x76, 0xf7, 0x18, 0x05, 0xaa, 0x4c, 0x8d, 0x48, 0x68, 0x14, 0xda, 0x89, 0x19, + 0x33, 0x86, 0x85, 0x69, 0xa1, 0x4a, 0xfd, 0x4e, 0xff, 0xc8, 0x6b, 0x32, 0x86, 0x77, 0x25, 0x59, + 0xdc, 0xe6, 0xeb, 0x52, 0x75, 0xdf, 0xb3, 0xfb, 0x21, 0xd0, 0x33, 0x33, 0xc7, 0x10, 0x72, 0x10, + 0x29, 0xaa, 0x18, 0xdf, 0xcd, 0x51, 0x69, 0xe7, 0x01, 0x6b, 0xa5, 0x53, 0xc8, 0xc4, 0x38, 0xab, + 0xc2, 0xb6, 0xe3, 0xed, 0xb2, 0x3e, 0xe1, 0xce, 0x90, 0xb5, 0xcb, 0xd1, 0xc7, 0x19, 0x57, 0x1d, + 0x7b, 0xef, 0x46, 0x6f, 0xa7, 0xff, 0xf8, 0x5a, 0x90, 0x6a, 0x6b, 0x36, 0x01, 0xca, 0x0e, 0x27, + 0x3c, 0x6e, 0x41, 0xb5, 0x50, 0xdd, 0xd7, 0xac, 0xf3, 0x67, 0x67, 0x55, 0x90, 0x50, 0xe8, 0x0c, + 0xd8, 0xf6, 0xa4, 0x7a, 0xb7, 0x1e, 0xf3, 0xd1, 0xbf, 0xdd, 0xcf, 0x20, 0x9f, 0x63, 0x5c, 0x6b, + 0xfa, 0x9f, 0x2d, 0x76, 0xfb, 0xd5, 0x1c, 0xe5, 0xf9, 0x29, 0xca, 0x45, 0x96, 0xa2, 0xf3, 0xd1, + 0x62, 0xf7, 0xae, 0x37, 0x73, 0x06, 0x8d, 0xb7, 0xee, 0x6f, 0xdb, 0xb3, 0xfb, 0xf4, 0x7f, 0xe5, + 0xd5, 0x8c, 0x07, 0xd6, 0xf0, 0x87, 0xfd, 0x75, 0xe9, 0x5a, 0x17, 0x4b, 0xd7, 0xfa, 0xb9, 0x74, + 0xad, 0x0f, 0x2b, 0x77, 0xeb, 0x62, 0xe5, 0x6e, 0x7d, 0x5f, 0xb9, 0x5b, 0xac, 0x97, 0xd2, 0xac, + 0x91, 0xff, 0xb0, 0x65, 0x8e, 0xd6, 0xfc, 0x80, 0x91, 0xf5, 0x26, 0x79, 0x9b, 0xe9, 0xe9, 0x7c, + 0x62, 0x50, 0x3f, 0x25, 0x35, 0x23, 0xe5, 0x4b, 0xcc, 0xe1, 0x1c, 0xa5, 0xbf, 0xe8, 0x6f, 0x96, + 0xe5, 0x21, 0x2a, 0xbf, 0xc9, 0x75, 0x79, 0xc2, 0x81, 0xea, 0xf5, 0x27, 0xfb, 0x66, 0x34, 0x1a, + 0x85, 0x5f, 0xec, 0xfd, 0xa8, 0xce, 0x35, 0x32, 0xb9, 0x46, 0x9b, 0x5c, 0x21, 0x90, 0x77, 0xb6, + 0xa6, 0xbf, 0x5d, 0x62, 0x89, 0xc1, 0x92, 0x0d, 0x96, 0x84, 0x40, 0x49, 0x8d, 0x2d, 0xed, 0x83, + 0x26, 0x58, 0x72, 0x1c, 0x0d, 0x5f, 0xa0, 0x06, 0x0e, 0x1a, 0x7e, 0xd9, 0xbd, 0x5a, 0x12, 0x04, + 0x46, 0x63, 0x9e, 0x6b, 0x51, 0x10, 0x84, 0x40, 0x41, 0x50, 0xcb, 0x26, 0xb7, 0xca, 0xab, 0x79, + 0xf4, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x34, 0x72, 0x78, 0x24, 0x1c, 0x04, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + DaoAssetBalances(ctx context.Context, in *DaoAssetBalancesRequest, opts ...grpc.CallOption) (QueryService_DaoAssetBalancesClient, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) DaoAssetBalances(ctx context.Context, in *DaoAssetBalancesRequest, opts ...grpc.CallOption) (QueryService_DaoAssetBalancesClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.core.component.dao.v1alpha1.QueryService/DaoAssetBalances", opts...) + if err != nil { + return nil, err + } + x := &queryServiceDaoAssetBalancesClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_DaoAssetBalancesClient interface { + Recv() (*DaoAssetBalancesResponse, error) + grpc.ClientStream +} + +type queryServiceDaoAssetBalancesClient struct { + grpc.ClientStream +} + +func (x *queryServiceDaoAssetBalancesClient) Recv() (*DaoAssetBalancesResponse, error) { + m := new(DaoAssetBalancesResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + DaoAssetBalances(*DaoAssetBalancesRequest, QueryService_DaoAssetBalancesServer) error +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) DaoAssetBalances(req *DaoAssetBalancesRequest, srv QueryService_DaoAssetBalancesServer) error { + return status.Errorf(codes.Unimplemented, "method DaoAssetBalances not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_DaoAssetBalances_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(DaoAssetBalancesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).DaoAssetBalances(m, &queryServiceDaoAssetBalancesServer{stream}) +} + +type QueryService_DaoAssetBalancesServer interface { + Send(*DaoAssetBalancesResponse) error + grpc.ServerStream +} + +type queryServiceDaoAssetBalancesServer struct { + grpc.ServerStream +} + +func (x *queryServiceDaoAssetBalancesServer) Send(m *DaoAssetBalancesResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.dao.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "DaoAssetBalances", + Handler: _QueryService_DaoAssetBalances_Handler, + ServerStreams: true, + }, + }, + Metadata: "penumbra/core/component/dao/v1alpha1/dao.proto", +} + +func (m *DaoParameters) 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 *DaoParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DaoParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DaoSpendProposalsEnabled { + i-- + if m.DaoSpendProposalsEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DaoParams != nil { + { + size, err := m.DaoParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDao(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DaoAssetBalancesRequest) 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 *DaoAssetBalancesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DaoAssetBalancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AssetIds) > 0 { + for iNdEx := len(m.AssetIds) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AssetIds[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDao(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDao(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DaoAssetBalancesResponse) 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 *DaoAssetBalancesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DaoAssetBalancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Balance != nil { + { + size, err := m.Balance.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDao(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintDao(dAtA []byte, offset int, v uint64) int { + offset -= sovDao(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *DaoParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DaoSpendProposalsEnabled { + n += 2 + } + return n +} + +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DaoParams != nil { + l = m.DaoParams.Size() + n += 1 + l + sovDao(uint64(l)) + } + return n +} + +func (m *DaoAssetBalancesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDao(uint64(l)) + } + if len(m.AssetIds) > 0 { + for _, e := range m.AssetIds { + l = e.Size() + n += 1 + l + sovDao(uint64(l)) + } + } + return n +} + +func (m *DaoAssetBalancesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Balance != nil { + l = m.Balance.Size() + n += 1 + l + sovDao(uint64(l)) + } + return n +} + +func sovDao(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozDao(x uint64) (n int) { + return sovDao(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *DaoParameters) 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 ErrIntOverflowDao + } + 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: DaoParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DaoParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DaoSpendProposalsEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDao + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DaoSpendProposalsEnabled = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipDao(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDao + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent) 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 ErrIntOverflowDao + } + 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: GenesisContent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DaoParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDao + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDao + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDao + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DaoParams == nil { + m.DaoParams = &DaoParameters{} + } + if err := m.DaoParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDao(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDao + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DaoAssetBalancesRequest) 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 ErrIntOverflowDao + } + 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: DaoAssetBalancesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DaoAssetBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDao + } + 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 ErrInvalidLengthDao + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDao + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetIds", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDao + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDao + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDao + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AssetIds = append(m.AssetIds, &v1alpha1.AssetId{}) + if err := m.AssetIds[len(m.AssetIds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDao(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDao + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DaoAssetBalancesResponse) 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 ErrIntOverflowDao + } + 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: DaoAssetBalancesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DaoAssetBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDao + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDao + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDao + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Balance == nil { + m.Balance = &v1alpha1.Value{} + } + if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDao(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDao + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipDao(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, ErrIntOverflowDao + } + 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, ErrIntOverflowDao + } + 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, ErrIntOverflowDao + } + 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, ErrInvalidLengthDao + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupDao + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthDao + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthDao = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDao = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupDao = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/component/dex/v1alpha1/dex.pb.go b/relayer/chains/penumbra/core/component/dex/v1alpha1/dex.pb.go new file mode 100644 index 000000000..1fd677763 --- /dev/null +++ b/relayer/chains/penumbra/core/component/dex/v1alpha1/dex.pb.go @@ -0,0 +1,17740 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/dex/v1alpha1/dex.proto + +package dexv1alpha1 + +import ( + context "context" + encoding_binary "encoding/binary" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + v1alpha14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1alpha1" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1alpha1" + v1alpha16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1alpha1" + v1alpha15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1" + v1alpha13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" + v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +type PositionState_PositionStateEnum int32 + +const ( + PositionState_POSITION_STATE_ENUM_UNSPECIFIED PositionState_PositionStateEnum = 0 + // The position has been opened, is active, has reserves and accumulated + // fees, and can be traded against. + PositionState_POSITION_STATE_ENUM_OPENED PositionState_PositionStateEnum = 1 + // The position has been closed, is inactive and can no longer be traded + // against, but still has reserves and accumulated fees. + PositionState_POSITION_STATE_ENUM_CLOSED PositionState_PositionStateEnum = 2 + // The final reserves and accumulated fees have been withdrawn, leaving an + // empty, inactive position awaiting (possible) retroactive rewards. + PositionState_POSITION_STATE_ENUM_WITHDRAWN PositionState_PositionStateEnum = 3 + // Any retroactive rewards have been claimed. The position is now an inert, + // historical artefact. + PositionState_POSITION_STATE_ENUM_CLAIMED PositionState_PositionStateEnum = 4 +) + +var PositionState_PositionStateEnum_name = map[int32]string{ + 0: "POSITION_STATE_ENUM_UNSPECIFIED", + 1: "POSITION_STATE_ENUM_OPENED", + 2: "POSITION_STATE_ENUM_CLOSED", + 3: "POSITION_STATE_ENUM_WITHDRAWN", + 4: "POSITION_STATE_ENUM_CLAIMED", +} + +var PositionState_PositionStateEnum_value = map[string]int32{ + "POSITION_STATE_ENUM_UNSPECIFIED": 0, + "POSITION_STATE_ENUM_OPENED": 1, + "POSITION_STATE_ENUM_CLOSED": 2, + "POSITION_STATE_ENUM_WITHDRAWN": 3, + "POSITION_STATE_ENUM_CLAIMED": 4, +} + +func (x PositionState_PositionStateEnum) String() string { + return proto.EnumName(PositionState_PositionStateEnum_name, int32(x)) +} + +func (PositionState_PositionStateEnum) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{20, 0} +} + +// A Penumbra ZK swap proof. +type ZKSwapProof struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *ZKSwapProof) Reset() { *m = ZKSwapProof{} } +func (m *ZKSwapProof) String() string { return proto.CompactTextString(m) } +func (*ZKSwapProof) ProtoMessage() {} +func (*ZKSwapProof) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{0} +} +func (m *ZKSwapProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZKSwapProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZKSwapProof.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 *ZKSwapProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZKSwapProof.Merge(m, src) +} +func (m *ZKSwapProof) XXX_Size() int { + return m.Size() +} +func (m *ZKSwapProof) XXX_DiscardUnknown() { + xxx_messageInfo_ZKSwapProof.DiscardUnknown(m) +} + +var xxx_messageInfo_ZKSwapProof proto.InternalMessageInfo + +func (m *ZKSwapProof) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// A Penumbra ZK swap claim proof. +type ZKSwapClaimProof struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *ZKSwapClaimProof) Reset() { *m = ZKSwapClaimProof{} } +func (m *ZKSwapClaimProof) String() string { return proto.CompactTextString(m) } +func (*ZKSwapClaimProof) ProtoMessage() {} +func (*ZKSwapClaimProof) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{1} +} +func (m *ZKSwapClaimProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZKSwapClaimProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZKSwapClaimProof.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 *ZKSwapClaimProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZKSwapClaimProof.Merge(m, src) +} +func (m *ZKSwapClaimProof) XXX_Size() int { + return m.Size() +} +func (m *ZKSwapClaimProof) XXX_DiscardUnknown() { + xxx_messageInfo_ZKSwapClaimProof.DiscardUnknown(m) +} + +var xxx_messageInfo_ZKSwapClaimProof proto.InternalMessageInfo + +func (m *ZKSwapClaimProof) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// A transaction action that submits a swap to the dex. +type Swap struct { + // Contains the Swap proof. + Proof *ZKSwapProof `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"` + // Encapsulates the authorized fields of the Swap action, used in signing. + Body *SwapBody `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"` +} + +func (m *Swap) Reset() { *m = Swap{} } +func (m *Swap) String() string { return proto.CompactTextString(m) } +func (*Swap) ProtoMessage() {} +func (*Swap) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{2} +} +func (m *Swap) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Swap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Swap.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 *Swap) XXX_Merge(src proto.Message) { + xxx_messageInfo_Swap.Merge(m, src) +} +func (m *Swap) XXX_Size() int { + return m.Size() +} +func (m *Swap) XXX_DiscardUnknown() { + xxx_messageInfo_Swap.DiscardUnknown(m) +} + +var xxx_messageInfo_Swap proto.InternalMessageInfo + +func (m *Swap) GetProof() *ZKSwapProof { + if m != nil { + return m.Proof + } + return nil +} + +func (m *Swap) GetBody() *SwapBody { + if m != nil { + return m.Body + } + return nil +} + +// A transaction action that obtains assets previously confirmed +// via a Swap transaction. Does not include a spend authorization +// signature, as it is only capable of consuming the NFT from a +// Swap transaction. +type SwapClaim struct { + // Contains the SwapClaim proof. + Proof *ZKSwapClaimProof `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"` + // Encapsulates the authorized fields of the SwapClaim action, used in signing. + Body *SwapClaimBody `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` + // The epoch duration of the chain when the swap claim took place. + EpochDuration uint64 `protobuf:"varint,7,opt,name=epoch_duration,json=epochDuration,proto3" json:"epoch_duration,omitempty"` +} + +func (m *SwapClaim) Reset() { *m = SwapClaim{} } +func (m *SwapClaim) String() string { return proto.CompactTextString(m) } +func (*SwapClaim) ProtoMessage() {} +func (*SwapClaim) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{3} +} +func (m *SwapClaim) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapClaim.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 *SwapClaim) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapClaim.Merge(m, src) +} +func (m *SwapClaim) XXX_Size() int { + return m.Size() +} +func (m *SwapClaim) XXX_DiscardUnknown() { + xxx_messageInfo_SwapClaim.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapClaim proto.InternalMessageInfo + +func (m *SwapClaim) GetProof() *ZKSwapClaimProof { + if m != nil { + return m.Proof + } + return nil +} + +func (m *SwapClaim) GetBody() *SwapClaimBody { + if m != nil { + return m.Body + } + return nil +} + +func (m *SwapClaim) GetEpochDuration() uint64 { + if m != nil { + return m.EpochDuration + } + return 0 +} + +// Encapsulates the authorized fields of the SwapClaim action, used in signing. +type SwapClaimBody struct { + // The nullifier for the Swap commitment to be consumed. + Nullifier *v1alpha1.Nullifier `protobuf:"bytes,1,opt,name=nullifier,proto3" json:"nullifier,omitempty"` + // The fee allows `SwapClaim` without an additional `Spend`. + Fee *v1alpha11.Fee `protobuf:"bytes,2,opt,name=fee,proto3" json:"fee,omitempty"` + // Note output for asset 1. + Output_1Commitment *v1alpha12.StateCommitment `protobuf:"bytes,3,opt,name=output_1_commitment,json=output1Commitment,proto3" json:"output_1_commitment,omitempty"` + // Note output for asset 2. + Output_2Commitment *v1alpha12.StateCommitment `protobuf:"bytes,4,opt,name=output_2_commitment,json=output2Commitment,proto3" json:"output_2_commitment,omitempty"` + // Input and output amounts, and asset IDs for the assets in the swap. + OutputData *BatchSwapOutputData `protobuf:"bytes,6,opt,name=output_data,json=outputData,proto3" json:"output_data,omitempty"` +} + +func (m *SwapClaimBody) Reset() { *m = SwapClaimBody{} } +func (m *SwapClaimBody) String() string { return proto.CompactTextString(m) } +func (*SwapClaimBody) ProtoMessage() {} +func (*SwapClaimBody) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{4} +} +func (m *SwapClaimBody) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapClaimBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapClaimBody.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 *SwapClaimBody) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapClaimBody.Merge(m, src) +} +func (m *SwapClaimBody) XXX_Size() int { + return m.Size() +} +func (m *SwapClaimBody) XXX_DiscardUnknown() { + xxx_messageInfo_SwapClaimBody.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapClaimBody proto.InternalMessageInfo + +func (m *SwapClaimBody) GetNullifier() *v1alpha1.Nullifier { + if m != nil { + return m.Nullifier + } + return nil +} + +func (m *SwapClaimBody) GetFee() *v1alpha11.Fee { + if m != nil { + return m.Fee + } + return nil +} + +func (m *SwapClaimBody) GetOutput_1Commitment() *v1alpha12.StateCommitment { + if m != nil { + return m.Output_1Commitment + } + return nil +} + +func (m *SwapClaimBody) GetOutput_2Commitment() *v1alpha12.StateCommitment { + if m != nil { + return m.Output_2Commitment + } + return nil +} + +func (m *SwapClaimBody) GetOutputData() *BatchSwapOutputData { + if m != nil { + return m.OutputData + } + return nil +} + +// The authorized data of a Swap transaction. +type SwapBody struct { + // The trading pair to swap. + TradingPair *TradingPair `protobuf:"bytes,1,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` + // The amount for asset 1. + Delta_1I *v1alpha13.Amount `protobuf:"bytes,2,opt,name=delta_1_i,json=delta1I,proto3" json:"delta_1_i,omitempty"` + // The amount for asset 2. + Delta_2I *v1alpha13.Amount `protobuf:"bytes,3,opt,name=delta_2_i,json=delta2I,proto3" json:"delta_2_i,omitempty"` + // A commitment to a prepaid fee for the future SwapClaim. + // This is recorded separately from delta_j_i because it's shielded; + // in the future we'll want separate commitments to each delta_j_i + // anyways in order to prove consistency with flow encryption. + FeeCommitment *v1alpha14.BalanceCommitment `protobuf:"bytes,4,opt,name=fee_commitment,json=feeCommitment,proto3" json:"fee_commitment,omitempty"` + // The swap commitment and encryption of the swap data. + Payload *SwapPayload `protobuf:"bytes,5,opt,name=payload,proto3" json:"payload,omitempty"` +} + +func (m *SwapBody) Reset() { *m = SwapBody{} } +func (m *SwapBody) String() string { return proto.CompactTextString(m) } +func (*SwapBody) ProtoMessage() {} +func (*SwapBody) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{5} +} +func (m *SwapBody) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapBody.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 *SwapBody) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapBody.Merge(m, src) +} +func (m *SwapBody) XXX_Size() int { + return m.Size() +} +func (m *SwapBody) XXX_DiscardUnknown() { + xxx_messageInfo_SwapBody.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapBody proto.InternalMessageInfo + +func (m *SwapBody) GetTradingPair() *TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +func (m *SwapBody) GetDelta_1I() *v1alpha13.Amount { + if m != nil { + return m.Delta_1I + } + return nil +} + +func (m *SwapBody) GetDelta_2I() *v1alpha13.Amount { + if m != nil { + return m.Delta_2I + } + return nil +} + +func (m *SwapBody) GetFeeCommitment() *v1alpha14.BalanceCommitment { + if m != nil { + return m.FeeCommitment + } + return nil +} + +func (m *SwapBody) GetPayload() *SwapPayload { + if m != nil { + return m.Payload + } + return nil +} + +type SwapPayload struct { + Commitment *v1alpha12.StateCommitment `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"` + EncryptedSwap []byte `protobuf:"bytes,2,opt,name=encrypted_swap,json=encryptedSwap,proto3" json:"encrypted_swap,omitempty"` +} + +func (m *SwapPayload) Reset() { *m = SwapPayload{} } +func (m *SwapPayload) String() string { return proto.CompactTextString(m) } +func (*SwapPayload) ProtoMessage() {} +func (*SwapPayload) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{6} +} +func (m *SwapPayload) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapPayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapPayload.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 *SwapPayload) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapPayload.Merge(m, src) +} +func (m *SwapPayload) XXX_Size() int { + return m.Size() +} +func (m *SwapPayload) XXX_DiscardUnknown() { + xxx_messageInfo_SwapPayload.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapPayload proto.InternalMessageInfo + +func (m *SwapPayload) GetCommitment() *v1alpha12.StateCommitment { + if m != nil { + return m.Commitment + } + return nil +} + +func (m *SwapPayload) GetEncryptedSwap() []byte { + if m != nil { + return m.EncryptedSwap + } + return nil +} + +type SwapPlaintext struct { + // The trading pair to swap. + TradingPair *TradingPair `protobuf:"bytes,1,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` + // Input amount of asset 1 + Delta_1I *v1alpha13.Amount `protobuf:"bytes,2,opt,name=delta_1_i,json=delta1I,proto3" json:"delta_1_i,omitempty"` + // Input amount of asset 2 + Delta_2I *v1alpha13.Amount `protobuf:"bytes,3,opt,name=delta_2_i,json=delta2I,proto3" json:"delta_2_i,omitempty"` + // Pre-paid fee to claim the swap + ClaimFee *v1alpha11.Fee `protobuf:"bytes,4,opt,name=claim_fee,json=claimFee,proto3" json:"claim_fee,omitempty"` + // Address that will claim the swap outputs via SwapClaim. + ClaimAddress *v1alpha15.Address `protobuf:"bytes,5,opt,name=claim_address,json=claimAddress,proto3" json:"claim_address,omitempty"` + // Swap rseed (blinding factors are derived from this) + Rseed []byte `protobuf:"bytes,6,opt,name=rseed,proto3" json:"rseed,omitempty"` +} + +func (m *SwapPlaintext) Reset() { *m = SwapPlaintext{} } +func (m *SwapPlaintext) String() string { return proto.CompactTextString(m) } +func (*SwapPlaintext) ProtoMessage() {} +func (*SwapPlaintext) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{7} +} +func (m *SwapPlaintext) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapPlaintext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapPlaintext.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 *SwapPlaintext) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapPlaintext.Merge(m, src) +} +func (m *SwapPlaintext) XXX_Size() int { + return m.Size() +} +func (m *SwapPlaintext) XXX_DiscardUnknown() { + xxx_messageInfo_SwapPlaintext.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapPlaintext proto.InternalMessageInfo + +func (m *SwapPlaintext) GetTradingPair() *TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +func (m *SwapPlaintext) GetDelta_1I() *v1alpha13.Amount { + if m != nil { + return m.Delta_1I + } + return nil +} + +func (m *SwapPlaintext) GetDelta_2I() *v1alpha13.Amount { + if m != nil { + return m.Delta_2I + } + return nil +} + +func (m *SwapPlaintext) GetClaimFee() *v1alpha11.Fee { + if m != nil { + return m.ClaimFee + } + return nil +} + +func (m *SwapPlaintext) GetClaimAddress() *v1alpha15.Address { + if m != nil { + return m.ClaimAddress + } + return nil +} + +func (m *SwapPlaintext) GetRseed() []byte { + if m != nil { + return m.Rseed + } + return nil +} + +type SwapPlan struct { + // The plaintext version of the swap to be performed. + SwapPlaintext *SwapPlaintext `protobuf:"bytes,1,opt,name=swap_plaintext,json=swapPlaintext,proto3" json:"swap_plaintext,omitempty"` + // The blinding factor for the fee commitment. The fee in the SwapPlan is private to prevent linkability with the SwapClaim. + FeeBlinding []byte `protobuf:"bytes,2,opt,name=fee_blinding,json=feeBlinding,proto3" json:"fee_blinding,omitempty"` + // The first blinding factor to use for the ZK swap proof. + ProofBlindingR []byte `protobuf:"bytes,3,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` + // The second blinding factor to use for the ZK swap proof. + ProofBlindingS []byte `protobuf:"bytes,4,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` +} + +func (m *SwapPlan) Reset() { *m = SwapPlan{} } +func (m *SwapPlan) String() string { return proto.CompactTextString(m) } +func (*SwapPlan) ProtoMessage() {} +func (*SwapPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{8} +} +func (m *SwapPlan) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapPlan.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 *SwapPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapPlan.Merge(m, src) +} +func (m *SwapPlan) XXX_Size() int { + return m.Size() +} +func (m *SwapPlan) XXX_DiscardUnknown() { + xxx_messageInfo_SwapPlan.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapPlan proto.InternalMessageInfo + +func (m *SwapPlan) GetSwapPlaintext() *SwapPlaintext { + if m != nil { + return m.SwapPlaintext + } + return nil +} + +func (m *SwapPlan) GetFeeBlinding() []byte { + if m != nil { + return m.FeeBlinding + } + return nil +} + +func (m *SwapPlan) GetProofBlindingR() []byte { + if m != nil { + return m.ProofBlindingR + } + return nil +} + +func (m *SwapPlan) GetProofBlindingS() []byte { + if m != nil { + return m.ProofBlindingS + } + return nil +} + +type SwapClaimPlan struct { + // The plaintext version of the swap to be performed. + SwapPlaintext *SwapPlaintext `protobuf:"bytes,1,opt,name=swap_plaintext,json=swapPlaintext,proto3" json:"swap_plaintext,omitempty"` + // The position of the swap commitment. + Position uint64 `protobuf:"varint,2,opt,name=position,proto3" json:"position,omitempty"` + // Input and output amounts for the Swap. + OutputData *BatchSwapOutputData `protobuf:"bytes,3,opt,name=output_data,json=outputData,proto3" json:"output_data,omitempty"` + // The epoch duration, used in proving. + EpochDuration uint64 `protobuf:"varint,4,opt,name=epoch_duration,json=epochDuration,proto3" json:"epoch_duration,omitempty"` + // The first blinding factor to use for the ZK swap claim proof. + ProofBlindingR []byte `protobuf:"bytes,5,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` + // The second blinding factor to use for the ZK swap claim proof. + ProofBlindingS []byte `protobuf:"bytes,6,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` +} + +func (m *SwapClaimPlan) Reset() { *m = SwapClaimPlan{} } +func (m *SwapClaimPlan) String() string { return proto.CompactTextString(m) } +func (*SwapClaimPlan) ProtoMessage() {} +func (*SwapClaimPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{9} +} +func (m *SwapClaimPlan) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapClaimPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapClaimPlan.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 *SwapClaimPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapClaimPlan.Merge(m, src) +} +func (m *SwapClaimPlan) XXX_Size() int { + return m.Size() +} +func (m *SwapClaimPlan) XXX_DiscardUnknown() { + xxx_messageInfo_SwapClaimPlan.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapClaimPlan proto.InternalMessageInfo + +func (m *SwapClaimPlan) GetSwapPlaintext() *SwapPlaintext { + if m != nil { + return m.SwapPlaintext + } + return nil +} + +func (m *SwapClaimPlan) GetPosition() uint64 { + if m != nil { + return m.Position + } + return 0 +} + +func (m *SwapClaimPlan) GetOutputData() *BatchSwapOutputData { + if m != nil { + return m.OutputData + } + return nil +} + +func (m *SwapClaimPlan) GetEpochDuration() uint64 { + if m != nil { + return m.EpochDuration + } + return 0 +} + +func (m *SwapClaimPlan) GetProofBlindingR() []byte { + if m != nil { + return m.ProofBlindingR + } + return nil +} + +func (m *SwapClaimPlan) GetProofBlindingS() []byte { + if m != nil { + return m.ProofBlindingS + } + return nil +} + +type SwapView struct { + // Types that are valid to be assigned to SwapView: + // + // *SwapView_Visible_ + // *SwapView_Opaque_ + SwapView isSwapView_SwapView `protobuf_oneof:"swap_view"` +} + +func (m *SwapView) Reset() { *m = SwapView{} } +func (m *SwapView) String() string { return proto.CompactTextString(m) } +func (*SwapView) ProtoMessage() {} +func (*SwapView) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{10} +} +func (m *SwapView) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapView.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 *SwapView) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapView.Merge(m, src) +} +func (m *SwapView) XXX_Size() int { + return m.Size() +} +func (m *SwapView) XXX_DiscardUnknown() { + xxx_messageInfo_SwapView.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapView proto.InternalMessageInfo + +type isSwapView_SwapView interface { + isSwapView_SwapView() + MarshalTo([]byte) (int, error) + Size() int +} + +type SwapView_Visible_ struct { + Visible *SwapView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` +} +type SwapView_Opaque_ struct { + Opaque *SwapView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +} + +func (*SwapView_Visible_) isSwapView_SwapView() {} +func (*SwapView_Opaque_) isSwapView_SwapView() {} + +func (m *SwapView) GetSwapView() isSwapView_SwapView { + if m != nil { + return m.SwapView + } + return nil +} + +func (m *SwapView) GetVisible() *SwapView_Visible { + if x, ok := m.GetSwapView().(*SwapView_Visible_); ok { + return x.Visible + } + return nil +} + +func (m *SwapView) GetOpaque() *SwapView_Opaque { + if x, ok := m.GetSwapView().(*SwapView_Opaque_); ok { + return x.Opaque + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*SwapView) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*SwapView_Visible_)(nil), + (*SwapView_Opaque_)(nil), + } +} + +type SwapView_Visible struct { + Swap *Swap `protobuf:"bytes,1,opt,name=swap,proto3" json:"swap,omitempty"` + SwapPlaintext *SwapPlaintext `protobuf:"bytes,3,opt,name=swap_plaintext,json=swapPlaintext,proto3" json:"swap_plaintext,omitempty"` +} + +func (m *SwapView_Visible) Reset() { *m = SwapView_Visible{} } +func (m *SwapView_Visible) String() string { return proto.CompactTextString(m) } +func (*SwapView_Visible) ProtoMessage() {} +func (*SwapView_Visible) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{10, 0} +} +func (m *SwapView_Visible) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapView_Visible.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 *SwapView_Visible) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapView_Visible.Merge(m, src) +} +func (m *SwapView_Visible) XXX_Size() int { + return m.Size() +} +func (m *SwapView_Visible) XXX_DiscardUnknown() { + xxx_messageInfo_SwapView_Visible.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapView_Visible proto.InternalMessageInfo + +func (m *SwapView_Visible) GetSwap() *Swap { + if m != nil { + return m.Swap + } + return nil +} + +func (m *SwapView_Visible) GetSwapPlaintext() *SwapPlaintext { + if m != nil { + return m.SwapPlaintext + } + return nil +} + +type SwapView_Opaque struct { + Swap *Swap `protobuf:"bytes,1,opt,name=swap,proto3" json:"swap,omitempty"` +} + +func (m *SwapView_Opaque) Reset() { *m = SwapView_Opaque{} } +func (m *SwapView_Opaque) String() string { return proto.CompactTextString(m) } +func (*SwapView_Opaque) ProtoMessage() {} +func (*SwapView_Opaque) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{10, 1} +} +func (m *SwapView_Opaque) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapView_Opaque.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 *SwapView_Opaque) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapView_Opaque.Merge(m, src) +} +func (m *SwapView_Opaque) XXX_Size() int { + return m.Size() +} +func (m *SwapView_Opaque) XXX_DiscardUnknown() { + xxx_messageInfo_SwapView_Opaque.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapView_Opaque proto.InternalMessageInfo + +func (m *SwapView_Opaque) GetSwap() *Swap { + if m != nil { + return m.Swap + } + return nil +} + +type SwapClaimView struct { + // Types that are valid to be assigned to SwapClaimView: + // + // *SwapClaimView_Visible_ + // *SwapClaimView_Opaque_ + SwapClaimView isSwapClaimView_SwapClaimView `protobuf_oneof:"swap_claim_view"` +} + +func (m *SwapClaimView) Reset() { *m = SwapClaimView{} } +func (m *SwapClaimView) String() string { return proto.CompactTextString(m) } +func (*SwapClaimView) ProtoMessage() {} +func (*SwapClaimView) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{11} +} +func (m *SwapClaimView) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapClaimView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapClaimView.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 *SwapClaimView) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapClaimView.Merge(m, src) +} +func (m *SwapClaimView) XXX_Size() int { + return m.Size() +} +func (m *SwapClaimView) XXX_DiscardUnknown() { + xxx_messageInfo_SwapClaimView.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapClaimView proto.InternalMessageInfo + +type isSwapClaimView_SwapClaimView interface { + isSwapClaimView_SwapClaimView() + MarshalTo([]byte) (int, error) + Size() int +} + +type SwapClaimView_Visible_ struct { + Visible *SwapClaimView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` +} +type SwapClaimView_Opaque_ struct { + Opaque *SwapClaimView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +} + +func (*SwapClaimView_Visible_) isSwapClaimView_SwapClaimView() {} +func (*SwapClaimView_Opaque_) isSwapClaimView_SwapClaimView() {} + +func (m *SwapClaimView) GetSwapClaimView() isSwapClaimView_SwapClaimView { + if m != nil { + return m.SwapClaimView + } + return nil +} + +func (m *SwapClaimView) GetVisible() *SwapClaimView_Visible { + if x, ok := m.GetSwapClaimView().(*SwapClaimView_Visible_); ok { + return x.Visible + } + return nil +} + +func (m *SwapClaimView) GetOpaque() *SwapClaimView_Opaque { + if x, ok := m.GetSwapClaimView().(*SwapClaimView_Opaque_); ok { + return x.Opaque + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*SwapClaimView) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*SwapClaimView_Visible_)(nil), + (*SwapClaimView_Opaque_)(nil), + } +} + +type SwapClaimView_Visible struct { + SwapClaim *SwapClaim `protobuf:"bytes,1,opt,name=swap_claim,json=swapClaim,proto3" json:"swap_claim,omitempty"` + Output_1 *v1alpha16.NoteView `protobuf:"bytes,2,opt,name=output_1,json=output1,proto3" json:"output_1,omitempty"` + Output_2 *v1alpha16.NoteView `protobuf:"bytes,3,opt,name=output_2,json=output2,proto3" json:"output_2,omitempty"` +} + +func (m *SwapClaimView_Visible) Reset() { *m = SwapClaimView_Visible{} } +func (m *SwapClaimView_Visible) String() string { return proto.CompactTextString(m) } +func (*SwapClaimView_Visible) ProtoMessage() {} +func (*SwapClaimView_Visible) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{11, 0} +} +func (m *SwapClaimView_Visible) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapClaimView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapClaimView_Visible.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 *SwapClaimView_Visible) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapClaimView_Visible.Merge(m, src) +} +func (m *SwapClaimView_Visible) XXX_Size() int { + return m.Size() +} +func (m *SwapClaimView_Visible) XXX_DiscardUnknown() { + xxx_messageInfo_SwapClaimView_Visible.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapClaimView_Visible proto.InternalMessageInfo + +func (m *SwapClaimView_Visible) GetSwapClaim() *SwapClaim { + if m != nil { + return m.SwapClaim + } + return nil +} + +func (m *SwapClaimView_Visible) GetOutput_1() *v1alpha16.NoteView { + if m != nil { + return m.Output_1 + } + return nil +} + +func (m *SwapClaimView_Visible) GetOutput_2() *v1alpha16.NoteView { + if m != nil { + return m.Output_2 + } + return nil +} + +type SwapClaimView_Opaque struct { + SwapClaim *SwapClaim `protobuf:"bytes,1,opt,name=swap_claim,json=swapClaim,proto3" json:"swap_claim,omitempty"` +} + +func (m *SwapClaimView_Opaque) Reset() { *m = SwapClaimView_Opaque{} } +func (m *SwapClaimView_Opaque) String() string { return proto.CompactTextString(m) } +func (*SwapClaimView_Opaque) ProtoMessage() {} +func (*SwapClaimView_Opaque) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{11, 1} +} +func (m *SwapClaimView_Opaque) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapClaimView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapClaimView_Opaque.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 *SwapClaimView_Opaque) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapClaimView_Opaque.Merge(m, src) +} +func (m *SwapClaimView_Opaque) XXX_Size() int { + return m.Size() +} +func (m *SwapClaimView_Opaque) XXX_DiscardUnknown() { + xxx_messageInfo_SwapClaimView_Opaque.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapClaimView_Opaque proto.InternalMessageInfo + +func (m *SwapClaimView_Opaque) GetSwapClaim() *SwapClaim { + if m != nil { + return m.SwapClaim + } + return nil +} + +// Holds two asset IDs. Ordering doesn't reflect trading direction. Instead, we +// require `asset_1 < asset_2` as field elements, to ensure a canonical +// representation of an unordered pair. +type TradingPair struct { + // The first asset of the pair. + Asset_1 *v1alpha14.AssetId `protobuf:"bytes,1,opt,name=asset_1,json=asset1,proto3" json:"asset_1,omitempty"` + // The second asset of the pair. + Asset_2 *v1alpha14.AssetId `protobuf:"bytes,2,opt,name=asset_2,json=asset2,proto3" json:"asset_2,omitempty"` +} + +func (m *TradingPair) Reset() { *m = TradingPair{} } +func (m *TradingPair) String() string { return proto.CompactTextString(m) } +func (*TradingPair) ProtoMessage() {} +func (*TradingPair) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{12} +} +func (m *TradingPair) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TradingPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TradingPair.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 *TradingPair) XXX_Merge(src proto.Message) { + xxx_messageInfo_TradingPair.Merge(m, src) +} +func (m *TradingPair) XXX_Size() int { + return m.Size() +} +func (m *TradingPair) XXX_DiscardUnknown() { + xxx_messageInfo_TradingPair.DiscardUnknown(m) +} + +var xxx_messageInfo_TradingPair proto.InternalMessageInfo + +func (m *TradingPair) GetAsset_1() *v1alpha14.AssetId { + if m != nil { + return m.Asset_1 + } + return nil +} + +func (m *TradingPair) GetAsset_2() *v1alpha14.AssetId { + if m != nil { + return m.Asset_2 + } + return nil +} + +// Encodes a trading pair starting from asset `start` +// and ending on asset `end`. +type DirectedTradingPair struct { + // The start asset of the pair. + Start *v1alpha14.AssetId `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"` + // The end asset of the pair. + End *v1alpha14.AssetId `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"` +} + +func (m *DirectedTradingPair) Reset() { *m = DirectedTradingPair{} } +func (m *DirectedTradingPair) String() string { return proto.CompactTextString(m) } +func (*DirectedTradingPair) ProtoMessage() {} +func (*DirectedTradingPair) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{13} +} +func (m *DirectedTradingPair) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DirectedTradingPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DirectedTradingPair.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 *DirectedTradingPair) XXX_Merge(src proto.Message) { + xxx_messageInfo_DirectedTradingPair.Merge(m, src) +} +func (m *DirectedTradingPair) XXX_Size() int { + return m.Size() +} +func (m *DirectedTradingPair) XXX_DiscardUnknown() { + xxx_messageInfo_DirectedTradingPair.DiscardUnknown(m) +} + +var xxx_messageInfo_DirectedTradingPair proto.InternalMessageInfo + +func (m *DirectedTradingPair) GetStart() *v1alpha14.AssetId { + if m != nil { + return m.Start + } + return nil +} + +func (m *DirectedTradingPair) GetEnd() *v1alpha14.AssetId { + if m != nil { + return m.End + } + return nil +} + +// Records the result of a batch swap on-chain. +// +// Used as a public input to a swap claim proof, as it implies the effective +// clearing price for the batch. +type BatchSwapOutputData struct { + // The total amount of asset 1 that was input to the batch swap. + Delta_1 *v1alpha13.Amount `protobuf:"bytes,1,opt,name=delta_1,json=delta1,proto3" json:"delta_1,omitempty"` + // The total amount of asset 2 that was input to the batch swap. + Delta_2 *v1alpha13.Amount `protobuf:"bytes,2,opt,name=delta_2,json=delta2,proto3" json:"delta_2,omitempty"` + // The total amount of asset 1 that was output from the batch swap for 2=>1 trades. + Lambda_1 *v1alpha13.Amount `protobuf:"bytes,3,opt,name=lambda_1,json=lambda1,proto3" json:"lambda_1,omitempty"` + // The total amount of asset 2 that was output from the batch swap for 1=>2 trades. + Lambda_2 *v1alpha13.Amount `protobuf:"bytes,4,opt,name=lambda_2,json=lambda2,proto3" json:"lambda_2,omitempty"` + // The total amount of asset 1 that was returned unfilled from the batch swap for 1=>2 trades. + Unfilled_1 *v1alpha13.Amount `protobuf:"bytes,5,opt,name=unfilled_1,json=unfilled1,proto3" json:"unfilled_1,omitempty"` + // The total amount of asset 2 that was returned unfilled from the batch swap for 2=>1 trades. + Unfilled_2 *v1alpha13.Amount `protobuf:"bytes,6,opt,name=unfilled_2,json=unfilled2,proto3" json:"unfilled_2,omitempty"` + // The height for which the batch swap data is valid. + Height uint64 `protobuf:"varint,7,opt,name=height,proto3" json:"height,omitempty"` + // The trading pair associated with the batch swap. + TradingPair *TradingPair `protobuf:"bytes,8,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` + // The starting block height of the epoch for which the batch swap data is valid. + EpochStartingHeight uint64 `protobuf:"varint,9,opt,name=epoch_starting_height,json=epochStartingHeight,proto3" json:"epoch_starting_height,omitempty"` +} + +func (m *BatchSwapOutputData) Reset() { *m = BatchSwapOutputData{} } +func (m *BatchSwapOutputData) String() string { return proto.CompactTextString(m) } +func (*BatchSwapOutputData) ProtoMessage() {} +func (*BatchSwapOutputData) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{14} +} +func (m *BatchSwapOutputData) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BatchSwapOutputData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BatchSwapOutputData.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 *BatchSwapOutputData) XXX_Merge(src proto.Message) { + xxx_messageInfo_BatchSwapOutputData.Merge(m, src) +} +func (m *BatchSwapOutputData) XXX_Size() int { + return m.Size() +} +func (m *BatchSwapOutputData) XXX_DiscardUnknown() { + xxx_messageInfo_BatchSwapOutputData.DiscardUnknown(m) +} + +var xxx_messageInfo_BatchSwapOutputData proto.InternalMessageInfo + +func (m *BatchSwapOutputData) GetDelta_1() *v1alpha13.Amount { + if m != nil { + return m.Delta_1 + } + return nil +} + +func (m *BatchSwapOutputData) GetDelta_2() *v1alpha13.Amount { + if m != nil { + return m.Delta_2 + } + return nil +} + +func (m *BatchSwapOutputData) GetLambda_1() *v1alpha13.Amount { + if m != nil { + return m.Lambda_1 + } + return nil +} + +func (m *BatchSwapOutputData) GetLambda_2() *v1alpha13.Amount { + if m != nil { + return m.Lambda_2 + } + return nil +} + +func (m *BatchSwapOutputData) GetUnfilled_1() *v1alpha13.Amount { + if m != nil { + return m.Unfilled_1 + } + return nil +} + +func (m *BatchSwapOutputData) GetUnfilled_2() *v1alpha13.Amount { + if m != nil { + return m.Unfilled_2 + } + return nil +} + +func (m *BatchSwapOutputData) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *BatchSwapOutputData) GetTradingPair() *TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +func (m *BatchSwapOutputData) GetEpochStartingHeight() uint64 { + if m != nil { + return m.EpochStartingHeight + } + return 0 +} + +// The trading function for a specific pair. +// For a pair (asset_1, asset_2), a trading function is defined by: +// `phi(R) = p*R_1 + q*R_2` and `gamma = 1 - fee`. +// The trading function is frequently referred to as "phi". +type TradingFunction struct { + Component *BareTradingFunction `protobuf:"bytes,1,opt,name=component,proto3" json:"component,omitempty"` + Pair *TradingPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` +} + +func (m *TradingFunction) Reset() { *m = TradingFunction{} } +func (m *TradingFunction) String() string { return proto.CompactTextString(m) } +func (*TradingFunction) ProtoMessage() {} +func (*TradingFunction) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{15} +} +func (m *TradingFunction) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TradingFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TradingFunction.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 *TradingFunction) XXX_Merge(src proto.Message) { + xxx_messageInfo_TradingFunction.Merge(m, src) +} +func (m *TradingFunction) XXX_Size() int { + return m.Size() +} +func (m *TradingFunction) XXX_DiscardUnknown() { + xxx_messageInfo_TradingFunction.DiscardUnknown(m) +} + +var xxx_messageInfo_TradingFunction proto.InternalMessageInfo + +func (m *TradingFunction) GetComponent() *BareTradingFunction { + if m != nil { + return m.Component + } + return nil +} + +func (m *TradingFunction) GetPair() *TradingPair { + if m != nil { + return m.Pair + } + return nil +} + +// The minimum amount of data describing a trading function. +// +// This implicitly treats the trading function as being between assets 1 and 2, +// without specifying what those assets are, to avoid duplicating data (each +// asset ID alone is twice the size of the trading function). +type BareTradingFunction struct { + Fee uint32 `protobuf:"varint,1,opt,name=fee,proto3" json:"fee,omitempty"` + // This is not actually an amount, it's an integer the same width as an amount + P *v1alpha13.Amount `protobuf:"bytes,2,opt,name=p,proto3" json:"p,omitempty"` + // This is not actually an amount, it's an integer the same width as an amount + Q *v1alpha13.Amount `protobuf:"bytes,3,opt,name=q,proto3" json:"q,omitempty"` +} + +func (m *BareTradingFunction) Reset() { *m = BareTradingFunction{} } +func (m *BareTradingFunction) String() string { return proto.CompactTextString(m) } +func (*BareTradingFunction) ProtoMessage() {} +func (*BareTradingFunction) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{16} +} +func (m *BareTradingFunction) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BareTradingFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BareTradingFunction.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 *BareTradingFunction) XXX_Merge(src proto.Message) { + xxx_messageInfo_BareTradingFunction.Merge(m, src) +} +func (m *BareTradingFunction) XXX_Size() int { + return m.Size() +} +func (m *BareTradingFunction) XXX_DiscardUnknown() { + xxx_messageInfo_BareTradingFunction.DiscardUnknown(m) +} + +var xxx_messageInfo_BareTradingFunction proto.InternalMessageInfo + +func (m *BareTradingFunction) GetFee() uint32 { + if m != nil { + return m.Fee + } + return 0 +} + +func (m *BareTradingFunction) GetP() *v1alpha13.Amount { + if m != nil { + return m.P + } + return nil +} + +func (m *BareTradingFunction) GetQ() *v1alpha13.Amount { + if m != nil { + return m.Q + } + return nil +} + +// The reserves of a position. +// +// Like a position, this implicitly treats the trading function as being +// between assets 1 and 2, without specifying what those assets are, to avoid +// duplicating data (each asset ID alone is four times the size of the +// reserves). +type Reserves struct { + R1 *v1alpha13.Amount `protobuf:"bytes,1,opt,name=r1,proto3" json:"r1,omitempty"` + R2 *v1alpha13.Amount `protobuf:"bytes,2,opt,name=r2,proto3" json:"r2,omitempty"` +} + +func (m *Reserves) Reset() { *m = Reserves{} } +func (m *Reserves) String() string { return proto.CompactTextString(m) } +func (*Reserves) ProtoMessage() {} +func (*Reserves) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{17} +} +func (m *Reserves) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Reserves) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Reserves.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 *Reserves) XXX_Merge(src proto.Message) { + xxx_messageInfo_Reserves.Merge(m, src) +} +func (m *Reserves) XXX_Size() int { + return m.Size() +} +func (m *Reserves) XXX_DiscardUnknown() { + xxx_messageInfo_Reserves.DiscardUnknown(m) +} + +var xxx_messageInfo_Reserves proto.InternalMessageInfo + +func (m *Reserves) GetR1() *v1alpha13.Amount { + if m != nil { + return m.R1 + } + return nil +} + +func (m *Reserves) GetR2() *v1alpha13.Amount { + if m != nil { + return m.R2 + } + return nil +} + +// Data identifying a position. +type Position struct { + Phi *TradingFunction `protobuf:"bytes,1,opt,name=phi,proto3" json:"phi,omitempty"` + // A random value used to disambiguate different positions with the exact same + // trading function. The chain should reject newly created positions with the + // same nonce as an existing position. This ensures that `PositionId`s will + // be unique, and allows us to track position ownership with a + // sequence of stateful NFTs based on the `PositionId`. + Nonce []byte `protobuf:"bytes,2,opt,name=nonce,proto3" json:"nonce,omitempty"` + State *PositionState `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"` + Reserves *Reserves `protobuf:"bytes,4,opt,name=reserves,proto3" json:"reserves,omitempty"` + // / If set to true, the position is a limit-order and will be closed + // / immediately after being filled. + CloseOnFill bool `protobuf:"varint,5,opt,name=close_on_fill,json=closeOnFill,proto3" json:"close_on_fill,omitempty"` +} + +func (m *Position) Reset() { *m = Position{} } +func (m *Position) String() string { return proto.CompactTextString(m) } +func (*Position) ProtoMessage() {} +func (*Position) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{18} +} +func (m *Position) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Position.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 *Position) XXX_Merge(src proto.Message) { + xxx_messageInfo_Position.Merge(m, src) +} +func (m *Position) XXX_Size() int { + return m.Size() +} +func (m *Position) XXX_DiscardUnknown() { + xxx_messageInfo_Position.DiscardUnknown(m) +} + +var xxx_messageInfo_Position proto.InternalMessageInfo + +func (m *Position) GetPhi() *TradingFunction { + if m != nil { + return m.Phi + } + return nil +} + +func (m *Position) GetNonce() []byte { + if m != nil { + return m.Nonce + } + return nil +} + +func (m *Position) GetState() *PositionState { + if m != nil { + return m.State + } + return nil +} + +func (m *Position) GetReserves() *Reserves { + if m != nil { + return m.Reserves + } + return nil +} + +func (m *Position) GetCloseOnFill() bool { + if m != nil { + return m.CloseOnFill + } + return false +} + +// A hash of a `Position`. +type PositionId struct { + // The bytes of the position ID. + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` + // Alternatively, a Bech32m-encoded string representation of the `inner` + // bytes. + // + // NOTE: implementations are not required to support parsing this field. + // Implementations should prefer to encode the bytes in all messages they + // produce. Implementations must not accept messages with both `inner` and + // `alt_bech32m` set. + AltBech32M string `protobuf:"bytes,2,opt,name=alt_bech32m,json=altBech32m,proto3" json:"alt_bech32m,omitempty"` +} + +func (m *PositionId) Reset() { *m = PositionId{} } +func (m *PositionId) String() string { return proto.CompactTextString(m) } +func (*PositionId) ProtoMessage() {} +func (*PositionId) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{19} +} +func (m *PositionId) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PositionId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PositionId.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 *PositionId) XXX_Merge(src proto.Message) { + xxx_messageInfo_PositionId.Merge(m, src) +} +func (m *PositionId) XXX_Size() int { + return m.Size() +} +func (m *PositionId) XXX_DiscardUnknown() { + xxx_messageInfo_PositionId.DiscardUnknown(m) +} + +var xxx_messageInfo_PositionId proto.InternalMessageInfo + +func (m *PositionId) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +func (m *PositionId) GetAltBech32M() string { + if m != nil { + return m.AltBech32M + } + return "" +} + +// The state of a position. +type PositionState struct { + State PositionState_PositionStateEnum `protobuf:"varint,1,opt,name=state,proto3,enum=penumbra.core.component.dex.v1alpha1.PositionState_PositionStateEnum" json:"state,omitempty"` +} + +func (m *PositionState) Reset() { *m = PositionState{} } +func (m *PositionState) String() string { return proto.CompactTextString(m) } +func (*PositionState) ProtoMessage() {} +func (*PositionState) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{20} +} +func (m *PositionState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PositionState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PositionState.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 *PositionState) XXX_Merge(src proto.Message) { + xxx_messageInfo_PositionState.Merge(m, src) +} +func (m *PositionState) XXX_Size() int { + return m.Size() +} +func (m *PositionState) XXX_DiscardUnknown() { + xxx_messageInfo_PositionState.DiscardUnknown(m) +} + +var xxx_messageInfo_PositionState proto.InternalMessageInfo + +func (m *PositionState) GetState() PositionState_PositionStateEnum { + if m != nil { + return m.State + } + return PositionState_POSITION_STATE_ENUM_UNSPECIFIED +} + +// An LPNFT tracking both ownership and state of a position. +// +// Tracking the state as part of the LPNFT means that all LP-related actions can +// be authorized by spending funds: a state transition (e.g., closing a +// position) is modeled as spending an "open position LPNFT" and minting a +// "closed position LPNFT" for the same (globally unique) position ID. +// +// This means that the LP mechanics can be agnostic to the mechanism used to +// record custody and spend authorization. For instance, they can be recorded +// in the shielded pool, where custody is based on off-chain keys, or they could +// be recorded in a programmatic on-chain account (in the future, e.g., to +// support interchain accounts). This also means that LP-related actions don't +// require any cryptographic implementation (proofs, signatures, etc), other +// than hooking into the value commitment mechanism used for transaction +// balances. +type LpNft struct { + PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + State *PositionState `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"` +} + +func (m *LpNft) Reset() { *m = LpNft{} } +func (m *LpNft) String() string { return proto.CompactTextString(m) } +func (*LpNft) ProtoMessage() {} +func (*LpNft) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{21} +} +func (m *LpNft) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LpNft) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LpNft.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 *LpNft) XXX_Merge(src proto.Message) { + xxx_messageInfo_LpNft.Merge(m, src) +} +func (m *LpNft) XXX_Size() int { + return m.Size() +} +func (m *LpNft) XXX_DiscardUnknown() { + xxx_messageInfo_LpNft.DiscardUnknown(m) +} + +var xxx_messageInfo_LpNft proto.InternalMessageInfo + +func (m *LpNft) GetPositionId() *PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +func (m *LpNft) GetState() *PositionState { + if m != nil { + return m.State + } + return nil +} + +// A transaction action that opens a new position. +// +// This action's contribution to the transaction's value balance is to consume +// the initial reserves and contribute an opened position NFT. +type PositionOpen struct { + // Contains the data defining the position, sufficient to compute its `PositionId`. + // + // Positions are immutable, so the `PositionData` (and hence the `PositionId`) + // are unchanged over the entire lifetime of the position. + Position *Position `protobuf:"bytes,1,opt,name=position,proto3" json:"position,omitempty"` +} + +func (m *PositionOpen) Reset() { *m = PositionOpen{} } +func (m *PositionOpen) String() string { return proto.CompactTextString(m) } +func (*PositionOpen) ProtoMessage() {} +func (*PositionOpen) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{22} +} +func (m *PositionOpen) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PositionOpen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PositionOpen.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 *PositionOpen) XXX_Merge(src proto.Message) { + xxx_messageInfo_PositionOpen.Merge(m, src) +} +func (m *PositionOpen) XXX_Size() int { + return m.Size() +} +func (m *PositionOpen) XXX_DiscardUnknown() { + xxx_messageInfo_PositionOpen.DiscardUnknown(m) +} + +var xxx_messageInfo_PositionOpen proto.InternalMessageInfo + +func (m *PositionOpen) GetPosition() *Position { + if m != nil { + return m.Position + } + return nil +} + +// A transaction action that closes a position. +// +// This action's contribution to the transaction's value balance is to consume +// an opened position NFT and contribute a closed position NFT. +// +// Closing a position does not immediately withdraw funds, because Penumbra +// transactions (like any ZK transaction model) are early-binding: the prover +// must know the state transition they prove knowledge of, and they cannot know +// the final reserves with certainty until after the position has been deactivated. +type PositionClose struct { + PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` +} + +func (m *PositionClose) Reset() { *m = PositionClose{} } +func (m *PositionClose) String() string { return proto.CompactTextString(m) } +func (*PositionClose) ProtoMessage() {} +func (*PositionClose) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{23} +} +func (m *PositionClose) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PositionClose) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PositionClose.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 *PositionClose) XXX_Merge(src proto.Message) { + xxx_messageInfo_PositionClose.Merge(m, src) +} +func (m *PositionClose) XXX_Size() int { + return m.Size() +} +func (m *PositionClose) XXX_DiscardUnknown() { + xxx_messageInfo_PositionClose.DiscardUnknown(m) +} + +var xxx_messageInfo_PositionClose proto.InternalMessageInfo + +func (m *PositionClose) GetPositionId() *PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +// A transaction action that withdraws funds from a closed position. +// +// This action's contribution to the transaction's value balance is to consume a +// closed position NFT and contribute a withdrawn position NFT, as well as all +// of the funds that were in the position at the time of closing. +type PositionWithdraw struct { + PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // A transparent (zero blinding factor) commitment to the position's final reserves and fees. + // + // The chain will check this commitment by recomputing it with the on-chain state. + ReservesCommitment *v1alpha14.BalanceCommitment `protobuf:"bytes,2,opt,name=reserves_commitment,json=reservesCommitment,proto3" json:"reserves_commitment,omitempty"` +} + +func (m *PositionWithdraw) Reset() { *m = PositionWithdraw{} } +func (m *PositionWithdraw) String() string { return proto.CompactTextString(m) } +func (*PositionWithdraw) ProtoMessage() {} +func (*PositionWithdraw) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{24} +} +func (m *PositionWithdraw) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PositionWithdraw) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PositionWithdraw.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 *PositionWithdraw) XXX_Merge(src proto.Message) { + xxx_messageInfo_PositionWithdraw.Merge(m, src) +} +func (m *PositionWithdraw) XXX_Size() int { + return m.Size() +} +func (m *PositionWithdraw) XXX_DiscardUnknown() { + xxx_messageInfo_PositionWithdraw.DiscardUnknown(m) +} + +var xxx_messageInfo_PositionWithdraw proto.InternalMessageInfo + +func (m *PositionWithdraw) GetPositionId() *PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +func (m *PositionWithdraw) GetReservesCommitment() *v1alpha14.BalanceCommitment { + if m != nil { + return m.ReservesCommitment + } + return nil +} + +// A transaction action that claims retroactive rewards for a historical +// position. +// +// This action's contribution to the transaction's value balance is to consume a +// withdrawn position NFT and contribute its reward balance. +type PositionRewardClaim struct { + PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // A transparent (zero blinding factor) commitment to the position's accumulated rewards. + // + // The chain will check this commitment by recomputing it with the on-chain state. + RewardsCommitment *v1alpha14.BalanceCommitment `protobuf:"bytes,2,opt,name=rewards_commitment,json=rewardsCommitment,proto3" json:"rewards_commitment,omitempty"` +} + +func (m *PositionRewardClaim) Reset() { *m = PositionRewardClaim{} } +func (m *PositionRewardClaim) String() string { return proto.CompactTextString(m) } +func (*PositionRewardClaim) ProtoMessage() {} +func (*PositionRewardClaim) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{25} +} +func (m *PositionRewardClaim) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PositionRewardClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PositionRewardClaim.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 *PositionRewardClaim) XXX_Merge(src proto.Message) { + xxx_messageInfo_PositionRewardClaim.Merge(m, src) +} +func (m *PositionRewardClaim) XXX_Size() int { + return m.Size() +} +func (m *PositionRewardClaim) XXX_DiscardUnknown() { + xxx_messageInfo_PositionRewardClaim.DiscardUnknown(m) +} + +var xxx_messageInfo_PositionRewardClaim proto.InternalMessageInfo + +func (m *PositionRewardClaim) GetPositionId() *PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +func (m *PositionRewardClaim) GetRewardsCommitment() *v1alpha14.BalanceCommitment { + if m != nil { + return m.RewardsCommitment + } + return nil +} + +// Contains the entire execution of a particular swap. +type SwapExecution struct { + Traces []*SwapExecution_Trace `protobuf:"bytes,1,rep,name=traces,proto3" json:"traces,omitempty"` + // The total input amount for this execution. + Input *v1alpha14.Value `protobuf:"bytes,2,opt,name=input,proto3" json:"input,omitempty"` + // The total output amount for this execution. + Output *v1alpha14.Value `protobuf:"bytes,3,opt,name=output,proto3" json:"output,omitempty"` +} + +func (m *SwapExecution) Reset() { *m = SwapExecution{} } +func (m *SwapExecution) String() string { return proto.CompactTextString(m) } +func (*SwapExecution) ProtoMessage() {} +func (*SwapExecution) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{26} +} +func (m *SwapExecution) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapExecution.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 *SwapExecution) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapExecution.Merge(m, src) +} +func (m *SwapExecution) XXX_Size() int { + return m.Size() +} +func (m *SwapExecution) XXX_DiscardUnknown() { + xxx_messageInfo_SwapExecution.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapExecution proto.InternalMessageInfo + +func (m *SwapExecution) GetTraces() []*SwapExecution_Trace { + if m != nil { + return m.Traces + } + return nil +} + +func (m *SwapExecution) GetInput() *v1alpha14.Value { + if m != nil { + return m.Input + } + return nil +} + +func (m *SwapExecution) GetOutput() *v1alpha14.Value { + if m != nil { + return m.Output + } + return nil +} + +// Contains all individual steps consisting of a trade trace. +type SwapExecution_Trace struct { + // Each step in the trade trace. + Value []*v1alpha14.Value `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"` +} + +func (m *SwapExecution_Trace) Reset() { *m = SwapExecution_Trace{} } +func (m *SwapExecution_Trace) String() string { return proto.CompactTextString(m) } +func (*SwapExecution_Trace) ProtoMessage() {} +func (*SwapExecution_Trace) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{26, 0} +} +func (m *SwapExecution_Trace) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapExecution_Trace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapExecution_Trace.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 *SwapExecution_Trace) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapExecution_Trace.Merge(m, src) +} +func (m *SwapExecution_Trace) XXX_Size() int { + return m.Size() +} +func (m *SwapExecution_Trace) XXX_DiscardUnknown() { + xxx_messageInfo_SwapExecution_Trace.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapExecution_Trace proto.InternalMessageInfo + +func (m *SwapExecution_Trace) GetValue() []*v1alpha14.Value { + if m != nil { + return m.Value + } + return nil +} + +// Contains private and public data for withdrawing funds from a closed position. +type PositionWithdrawPlan struct { + Reserves *Reserves `protobuf:"bytes,1,opt,name=reserves,proto3" json:"reserves,omitempty"` + PositionId *PositionId `protobuf:"bytes,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + Pair *TradingPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` +} + +func (m *PositionWithdrawPlan) Reset() { *m = PositionWithdrawPlan{} } +func (m *PositionWithdrawPlan) String() string { return proto.CompactTextString(m) } +func (*PositionWithdrawPlan) ProtoMessage() {} +func (*PositionWithdrawPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{27} +} +func (m *PositionWithdrawPlan) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PositionWithdrawPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PositionWithdrawPlan.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 *PositionWithdrawPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_PositionWithdrawPlan.Merge(m, src) +} +func (m *PositionWithdrawPlan) XXX_Size() int { + return m.Size() +} +func (m *PositionWithdrawPlan) XXX_DiscardUnknown() { + xxx_messageInfo_PositionWithdrawPlan.DiscardUnknown(m) +} + +var xxx_messageInfo_PositionWithdrawPlan proto.InternalMessageInfo + +func (m *PositionWithdrawPlan) GetReserves() *Reserves { + if m != nil { + return m.Reserves + } + return nil +} + +func (m *PositionWithdrawPlan) GetPositionId() *PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +func (m *PositionWithdrawPlan) GetPair() *TradingPair { + if m != nil { + return m.Pair + } + return nil +} + +// Contains private and public data for claiming rewards from a position. +type PositionRewardClaimPlan struct { + Reserves *Reserves `protobuf:"bytes,1,opt,name=reserves,proto3" json:"reserves,omitempty"` +} + +func (m *PositionRewardClaimPlan) Reset() { *m = PositionRewardClaimPlan{} } +func (m *PositionRewardClaimPlan) String() string { return proto.CompactTextString(m) } +func (*PositionRewardClaimPlan) ProtoMessage() {} +func (*PositionRewardClaimPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{28} +} +func (m *PositionRewardClaimPlan) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PositionRewardClaimPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PositionRewardClaimPlan.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 *PositionRewardClaimPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_PositionRewardClaimPlan.Merge(m, src) +} +func (m *PositionRewardClaimPlan) XXX_Size() int { + return m.Size() +} +func (m *PositionRewardClaimPlan) XXX_DiscardUnknown() { + xxx_messageInfo_PositionRewardClaimPlan.DiscardUnknown(m) +} + +var xxx_messageInfo_PositionRewardClaimPlan proto.InternalMessageInfo + +func (m *PositionRewardClaimPlan) GetReserves() *Reserves { + if m != nil { + return m.Reserves + } + return nil +} + +// Requests batch swap data associated with a given height and trading pair from the view service. +type BatchSwapOutputDataRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` + TradingPair *TradingPair `protobuf:"bytes,3,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` +} + +func (m *BatchSwapOutputDataRequest) Reset() { *m = BatchSwapOutputDataRequest{} } +func (m *BatchSwapOutputDataRequest) String() string { return proto.CompactTextString(m) } +func (*BatchSwapOutputDataRequest) ProtoMessage() {} +func (*BatchSwapOutputDataRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{29} +} +func (m *BatchSwapOutputDataRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BatchSwapOutputDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BatchSwapOutputDataRequest.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 *BatchSwapOutputDataRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BatchSwapOutputDataRequest.Merge(m, src) +} +func (m *BatchSwapOutputDataRequest) XXX_Size() int { + return m.Size() +} +func (m *BatchSwapOutputDataRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BatchSwapOutputDataRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_BatchSwapOutputDataRequest proto.InternalMessageInfo + +func (m *BatchSwapOutputDataRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *BatchSwapOutputDataRequest) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *BatchSwapOutputDataRequest) GetTradingPair() *TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +type BatchSwapOutputDataResponse struct { + Data *BatchSwapOutputData `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *BatchSwapOutputDataResponse) Reset() { *m = BatchSwapOutputDataResponse{} } +func (m *BatchSwapOutputDataResponse) String() string { return proto.CompactTextString(m) } +func (*BatchSwapOutputDataResponse) ProtoMessage() {} +func (*BatchSwapOutputDataResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{30} +} +func (m *BatchSwapOutputDataResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BatchSwapOutputDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BatchSwapOutputDataResponse.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 *BatchSwapOutputDataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BatchSwapOutputDataResponse.Merge(m, src) +} +func (m *BatchSwapOutputDataResponse) XXX_Size() int { + return m.Size() +} +func (m *BatchSwapOutputDataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BatchSwapOutputDataResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_BatchSwapOutputDataResponse proto.InternalMessageInfo + +func (m *BatchSwapOutputDataResponse) GetData() *BatchSwapOutputData { + if m != nil { + return m.Data + } + return nil +} + +type SwapExecutionRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` + TradingPair *DirectedTradingPair `protobuf:"bytes,3,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` +} + +func (m *SwapExecutionRequest) Reset() { *m = SwapExecutionRequest{} } +func (m *SwapExecutionRequest) String() string { return proto.CompactTextString(m) } +func (*SwapExecutionRequest) ProtoMessage() {} +func (*SwapExecutionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{31} +} +func (m *SwapExecutionRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapExecutionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapExecutionRequest.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 *SwapExecutionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapExecutionRequest.Merge(m, src) +} +func (m *SwapExecutionRequest) XXX_Size() int { + return m.Size() +} +func (m *SwapExecutionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SwapExecutionRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapExecutionRequest proto.InternalMessageInfo + +func (m *SwapExecutionRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *SwapExecutionRequest) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *SwapExecutionRequest) GetTradingPair() *DirectedTradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +type SwapExecutionResponse struct { + SwapExecution *SwapExecution `protobuf:"bytes,1,opt,name=swap_execution,json=swapExecution,proto3" json:"swap_execution,omitempty"` +} + +func (m *SwapExecutionResponse) Reset() { *m = SwapExecutionResponse{} } +func (m *SwapExecutionResponse) String() string { return proto.CompactTextString(m) } +func (*SwapExecutionResponse) ProtoMessage() {} +func (*SwapExecutionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{32} +} +func (m *SwapExecutionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapExecutionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapExecutionResponse.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 *SwapExecutionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapExecutionResponse.Merge(m, src) +} +func (m *SwapExecutionResponse) XXX_Size() int { + return m.Size() +} +func (m *SwapExecutionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SwapExecutionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapExecutionResponse proto.InternalMessageInfo + +func (m *SwapExecutionResponse) GetSwapExecution() *SwapExecution { + if m != nil { + return m.SwapExecution + } + return nil +} + +type ArbExecutionRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *ArbExecutionRequest) Reset() { *m = ArbExecutionRequest{} } +func (m *ArbExecutionRequest) String() string { return proto.CompactTextString(m) } +func (*ArbExecutionRequest) ProtoMessage() {} +func (*ArbExecutionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{33} +} +func (m *ArbExecutionRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ArbExecutionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ArbExecutionRequest.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 *ArbExecutionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ArbExecutionRequest.Merge(m, src) +} +func (m *ArbExecutionRequest) XXX_Size() int { + return m.Size() +} +func (m *ArbExecutionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ArbExecutionRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ArbExecutionRequest proto.InternalMessageInfo + +func (m *ArbExecutionRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *ArbExecutionRequest) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +type ArbExecutionResponse struct { + SwapExecution *SwapExecution `protobuf:"bytes,1,opt,name=swap_execution,json=swapExecution,proto3" json:"swap_execution,omitempty"` + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *ArbExecutionResponse) Reset() { *m = ArbExecutionResponse{} } +func (m *ArbExecutionResponse) String() string { return proto.CompactTextString(m) } +func (*ArbExecutionResponse) ProtoMessage() {} +func (*ArbExecutionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{34} +} +func (m *ArbExecutionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ArbExecutionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ArbExecutionResponse.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 *ArbExecutionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ArbExecutionResponse.Merge(m, src) +} +func (m *ArbExecutionResponse) XXX_Size() int { + return m.Size() +} +func (m *ArbExecutionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ArbExecutionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ArbExecutionResponse proto.InternalMessageInfo + +func (m *ArbExecutionResponse) GetSwapExecution() *SwapExecution { + if m != nil { + return m.SwapExecution + } + return nil +} + +func (m *ArbExecutionResponse) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +type SwapExecutionsRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // If present, only return swap executions occurring after the given height. + StartHeight uint64 `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` + // If present, only return swap executions occurring before the given height. + EndHeight uint64 `protobuf:"varint,3,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"` + // If present, filter swap executions by the given trading pair. + TradingPair *DirectedTradingPair `protobuf:"bytes,4,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` +} + +func (m *SwapExecutionsRequest) Reset() { *m = SwapExecutionsRequest{} } +func (m *SwapExecutionsRequest) String() string { return proto.CompactTextString(m) } +func (*SwapExecutionsRequest) ProtoMessage() {} +func (*SwapExecutionsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{35} +} +func (m *SwapExecutionsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapExecutionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapExecutionsRequest.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 *SwapExecutionsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapExecutionsRequest.Merge(m, src) +} +func (m *SwapExecutionsRequest) XXX_Size() int { + return m.Size() +} +func (m *SwapExecutionsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SwapExecutionsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapExecutionsRequest proto.InternalMessageInfo + +func (m *SwapExecutionsRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *SwapExecutionsRequest) GetStartHeight() uint64 { + if m != nil { + return m.StartHeight + } + return 0 +} + +func (m *SwapExecutionsRequest) GetEndHeight() uint64 { + if m != nil { + return m.EndHeight + } + return 0 +} + +func (m *SwapExecutionsRequest) GetTradingPair() *DirectedTradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +type SwapExecutionsResponse struct { + SwapExecution *SwapExecution `protobuf:"bytes,1,opt,name=swap_execution,json=swapExecution,proto3" json:"swap_execution,omitempty"` + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` + TradingPair *DirectedTradingPair `protobuf:"bytes,3,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` +} + +func (m *SwapExecutionsResponse) Reset() { *m = SwapExecutionsResponse{} } +func (m *SwapExecutionsResponse) String() string { return proto.CompactTextString(m) } +func (*SwapExecutionsResponse) ProtoMessage() {} +func (*SwapExecutionsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{36} +} +func (m *SwapExecutionsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapExecutionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapExecutionsResponse.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 *SwapExecutionsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapExecutionsResponse.Merge(m, src) +} +func (m *SwapExecutionsResponse) XXX_Size() int { + return m.Size() +} +func (m *SwapExecutionsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SwapExecutionsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapExecutionsResponse proto.InternalMessageInfo + +func (m *SwapExecutionsResponse) GetSwapExecution() *SwapExecution { + if m != nil { + return m.SwapExecution + } + return nil +} + +func (m *SwapExecutionsResponse) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *SwapExecutionsResponse) GetTradingPair() *DirectedTradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +type ArbExecutionsRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // If present, only return arb executions occurring after the given height. + StartHeight uint64 `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` + // If present, only return arb executions occurring before the given height. + EndHeight uint64 `protobuf:"varint,3,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"` +} + +func (m *ArbExecutionsRequest) Reset() { *m = ArbExecutionsRequest{} } +func (m *ArbExecutionsRequest) String() string { return proto.CompactTextString(m) } +func (*ArbExecutionsRequest) ProtoMessage() {} +func (*ArbExecutionsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{37} +} +func (m *ArbExecutionsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ArbExecutionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ArbExecutionsRequest.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 *ArbExecutionsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ArbExecutionsRequest.Merge(m, src) +} +func (m *ArbExecutionsRequest) XXX_Size() int { + return m.Size() +} +func (m *ArbExecutionsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ArbExecutionsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ArbExecutionsRequest proto.InternalMessageInfo + +func (m *ArbExecutionsRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *ArbExecutionsRequest) GetStartHeight() uint64 { + if m != nil { + return m.StartHeight + } + return 0 +} + +func (m *ArbExecutionsRequest) GetEndHeight() uint64 { + if m != nil { + return m.EndHeight + } + return 0 +} + +type ArbExecutionsResponse struct { + SwapExecution *SwapExecution `protobuf:"bytes,1,opt,name=swap_execution,json=swapExecution,proto3" json:"swap_execution,omitempty"` + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *ArbExecutionsResponse) Reset() { *m = ArbExecutionsResponse{} } +func (m *ArbExecutionsResponse) String() string { return proto.CompactTextString(m) } +func (*ArbExecutionsResponse) ProtoMessage() {} +func (*ArbExecutionsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{38} +} +func (m *ArbExecutionsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ArbExecutionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ArbExecutionsResponse.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 *ArbExecutionsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ArbExecutionsResponse.Merge(m, src) +} +func (m *ArbExecutionsResponse) XXX_Size() int { + return m.Size() +} +func (m *ArbExecutionsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ArbExecutionsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ArbExecutionsResponse proto.InternalMessageInfo + +func (m *ArbExecutionsResponse) GetSwapExecution() *SwapExecution { + if m != nil { + return m.SwapExecution + } + return nil +} + +func (m *ArbExecutionsResponse) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +type LiquidityPositionsRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // If true, include closed and withdrawn positions. + IncludeClosed bool `protobuf:"varint,4,opt,name=include_closed,json=includeClosed,proto3" json:"include_closed,omitempty"` +} + +func (m *LiquidityPositionsRequest) Reset() { *m = LiquidityPositionsRequest{} } +func (m *LiquidityPositionsRequest) String() string { return proto.CompactTextString(m) } +func (*LiquidityPositionsRequest) ProtoMessage() {} +func (*LiquidityPositionsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{39} +} +func (m *LiquidityPositionsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityPositionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityPositionsRequest.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 *LiquidityPositionsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityPositionsRequest.Merge(m, src) +} +func (m *LiquidityPositionsRequest) XXX_Size() int { + return m.Size() +} +func (m *LiquidityPositionsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityPositionsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityPositionsRequest proto.InternalMessageInfo + +func (m *LiquidityPositionsRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *LiquidityPositionsRequest) GetIncludeClosed() bool { + if m != nil { + return m.IncludeClosed + } + return false +} + +type LiquidityPositionsResponse struct { + Data *Position `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *LiquidityPositionsResponse) Reset() { *m = LiquidityPositionsResponse{} } +func (m *LiquidityPositionsResponse) String() string { return proto.CompactTextString(m) } +func (*LiquidityPositionsResponse) ProtoMessage() {} +func (*LiquidityPositionsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{40} +} +func (m *LiquidityPositionsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityPositionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityPositionsResponse.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 *LiquidityPositionsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityPositionsResponse.Merge(m, src) +} +func (m *LiquidityPositionsResponse) XXX_Size() int { + return m.Size() +} +func (m *LiquidityPositionsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityPositionsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityPositionsResponse proto.InternalMessageInfo + +func (m *LiquidityPositionsResponse) GetData() *Position { + if m != nil { + return m.Data + } + return nil +} + +type LiquidityPositionByIdRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + PositionId *PositionId `protobuf:"bytes,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` +} + +func (m *LiquidityPositionByIdRequest) Reset() { *m = LiquidityPositionByIdRequest{} } +func (m *LiquidityPositionByIdRequest) String() string { return proto.CompactTextString(m) } +func (*LiquidityPositionByIdRequest) ProtoMessage() {} +func (*LiquidityPositionByIdRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{41} +} +func (m *LiquidityPositionByIdRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityPositionByIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityPositionByIdRequest.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 *LiquidityPositionByIdRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityPositionByIdRequest.Merge(m, src) +} +func (m *LiquidityPositionByIdRequest) XXX_Size() int { + return m.Size() +} +func (m *LiquidityPositionByIdRequest) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityPositionByIdRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityPositionByIdRequest proto.InternalMessageInfo + +func (m *LiquidityPositionByIdRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *LiquidityPositionByIdRequest) GetPositionId() *PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +type LiquidityPositionByIdResponse struct { + Data *Position `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *LiquidityPositionByIdResponse) Reset() { *m = LiquidityPositionByIdResponse{} } +func (m *LiquidityPositionByIdResponse) String() string { return proto.CompactTextString(m) } +func (*LiquidityPositionByIdResponse) ProtoMessage() {} +func (*LiquidityPositionByIdResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{42} +} +func (m *LiquidityPositionByIdResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityPositionByIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityPositionByIdResponse.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 *LiquidityPositionByIdResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityPositionByIdResponse.Merge(m, src) +} +func (m *LiquidityPositionByIdResponse) XXX_Size() int { + return m.Size() +} +func (m *LiquidityPositionByIdResponse) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityPositionByIdResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityPositionByIdResponse proto.InternalMessageInfo + +func (m *LiquidityPositionByIdResponse) GetData() *Position { + if m != nil { + return m.Data + } + return nil +} + +type LiquidityPositionsByIdRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + PositionId []*PositionId `protobuf:"bytes,2,rep,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` +} + +func (m *LiquidityPositionsByIdRequest) Reset() { *m = LiquidityPositionsByIdRequest{} } +func (m *LiquidityPositionsByIdRequest) String() string { return proto.CompactTextString(m) } +func (*LiquidityPositionsByIdRequest) ProtoMessage() {} +func (*LiquidityPositionsByIdRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{43} +} +func (m *LiquidityPositionsByIdRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityPositionsByIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityPositionsByIdRequest.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 *LiquidityPositionsByIdRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityPositionsByIdRequest.Merge(m, src) +} +func (m *LiquidityPositionsByIdRequest) XXX_Size() int { + return m.Size() +} +func (m *LiquidityPositionsByIdRequest) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityPositionsByIdRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityPositionsByIdRequest proto.InternalMessageInfo + +func (m *LiquidityPositionsByIdRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *LiquidityPositionsByIdRequest) GetPositionId() []*PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +type LiquidityPositionsByIdResponse struct { + Data *Position `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *LiquidityPositionsByIdResponse) Reset() { *m = LiquidityPositionsByIdResponse{} } +func (m *LiquidityPositionsByIdResponse) String() string { return proto.CompactTextString(m) } +func (*LiquidityPositionsByIdResponse) ProtoMessage() {} +func (*LiquidityPositionsByIdResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{44} +} +func (m *LiquidityPositionsByIdResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityPositionsByIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityPositionsByIdResponse.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 *LiquidityPositionsByIdResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityPositionsByIdResponse.Merge(m, src) +} +func (m *LiquidityPositionsByIdResponse) XXX_Size() int { + return m.Size() +} +func (m *LiquidityPositionsByIdResponse) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityPositionsByIdResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityPositionsByIdResponse proto.InternalMessageInfo + +func (m *LiquidityPositionsByIdResponse) GetData() *Position { + if m != nil { + return m.Data + } + return nil +} + +type LiquidityPositionsByPriceRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The directed trading pair to request positions for + TradingPair *DirectedTradingPair `protobuf:"bytes,2,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` + // The maximum number of positions to return. + Limit uint64 `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"` +} + +func (m *LiquidityPositionsByPriceRequest) Reset() { *m = LiquidityPositionsByPriceRequest{} } +func (m *LiquidityPositionsByPriceRequest) String() string { return proto.CompactTextString(m) } +func (*LiquidityPositionsByPriceRequest) ProtoMessage() {} +func (*LiquidityPositionsByPriceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{45} +} +func (m *LiquidityPositionsByPriceRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityPositionsByPriceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityPositionsByPriceRequest.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 *LiquidityPositionsByPriceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityPositionsByPriceRequest.Merge(m, src) +} +func (m *LiquidityPositionsByPriceRequest) XXX_Size() int { + return m.Size() +} +func (m *LiquidityPositionsByPriceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityPositionsByPriceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityPositionsByPriceRequest proto.InternalMessageInfo + +func (m *LiquidityPositionsByPriceRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *LiquidityPositionsByPriceRequest) GetTradingPair() *DirectedTradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +func (m *LiquidityPositionsByPriceRequest) GetLimit() uint64 { + if m != nil { + return m.Limit + } + return 0 +} + +type LiquidityPositionsByPriceResponse struct { + Data *Position `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *LiquidityPositionsByPriceResponse) Reset() { *m = LiquidityPositionsByPriceResponse{} } +func (m *LiquidityPositionsByPriceResponse) String() string { return proto.CompactTextString(m) } +func (*LiquidityPositionsByPriceResponse) ProtoMessage() {} +func (*LiquidityPositionsByPriceResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{46} +} +func (m *LiquidityPositionsByPriceResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityPositionsByPriceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityPositionsByPriceResponse.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 *LiquidityPositionsByPriceResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityPositionsByPriceResponse.Merge(m, src) +} +func (m *LiquidityPositionsByPriceResponse) XXX_Size() int { + return m.Size() +} +func (m *LiquidityPositionsByPriceResponse) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityPositionsByPriceResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityPositionsByPriceResponse proto.InternalMessageInfo + +func (m *LiquidityPositionsByPriceResponse) GetData() *Position { + if m != nil { + return m.Data + } + return nil +} + +type SpreadRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + TradingPair *TradingPair `protobuf:"bytes,2,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` +} + +func (m *SpreadRequest) Reset() { *m = SpreadRequest{} } +func (m *SpreadRequest) String() string { return proto.CompactTextString(m) } +func (*SpreadRequest) ProtoMessage() {} +func (*SpreadRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{47} +} +func (m *SpreadRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpreadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpreadRequest.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 *SpreadRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpreadRequest.Merge(m, src) +} +func (m *SpreadRequest) XXX_Size() int { + return m.Size() +} +func (m *SpreadRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SpreadRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SpreadRequest proto.InternalMessageInfo + +func (m *SpreadRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *SpreadRequest) GetTradingPair() *TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +type SpreadResponse struct { + // The best position when trading 1 => 2. + Best_1To_2Position *Position `protobuf:"bytes,1,opt,name=best_1_to_2_position,json=best1To2Position,proto3" json:"best_1_to_2_position,omitempty"` + // The best position when trading 2 => 1. + Best_2To_1Position *Position `protobuf:"bytes,2,opt,name=best_2_to_1_position,json=best2To1Position,proto3" json:"best_2_to_1_position,omitempty"` + // An approximation of the effective price when trading 1 => 2. + ApproxEffectivePrice_1To_2 float64 `protobuf:"fixed64,3,opt,name=approx_effective_price_1_to_2,json=approxEffectivePrice1To2,proto3" json:"approx_effective_price_1_to_2,omitempty"` + // An approximation of the effective price when trading 2 => 1. + ApproxEffectivePrice_2To_1 float64 `protobuf:"fixed64,4,opt,name=approx_effective_price_2_to_1,json=approxEffectivePrice2To1,proto3" json:"approx_effective_price_2_to_1,omitempty"` +} + +func (m *SpreadResponse) Reset() { *m = SpreadResponse{} } +func (m *SpreadResponse) String() string { return proto.CompactTextString(m) } +func (*SpreadResponse) ProtoMessage() {} +func (*SpreadResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{48} +} +func (m *SpreadResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpreadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpreadResponse.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 *SpreadResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpreadResponse.Merge(m, src) +} +func (m *SpreadResponse) XXX_Size() int { + return m.Size() +} +func (m *SpreadResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SpreadResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SpreadResponse proto.InternalMessageInfo + +func (m *SpreadResponse) GetBest_1To_2Position() *Position { + if m != nil { + return m.Best_1To_2Position + } + return nil +} + +func (m *SpreadResponse) GetBest_2To_1Position() *Position { + if m != nil { + return m.Best_2To_1Position + } + return nil +} + +func (m *SpreadResponse) GetApproxEffectivePrice_1To_2() float64 { + if m != nil { + return m.ApproxEffectivePrice_1To_2 + } + return 0 +} + +func (m *SpreadResponse) GetApproxEffectivePrice_2To_1() float64 { + if m != nil { + return m.ApproxEffectivePrice_2To_1 + } + return 0 +} + +type SimulateTradeRequest struct { + Input *v1alpha14.Value `protobuf:"bytes,1,opt,name=input,proto3" json:"input,omitempty"` + Output *v1alpha14.AssetId `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"` + Routing *SimulateTradeRequest_Routing `protobuf:"bytes,3,opt,name=routing,proto3" json:"routing,omitempty"` +} + +func (m *SimulateTradeRequest) Reset() { *m = SimulateTradeRequest{} } +func (m *SimulateTradeRequest) String() string { return proto.CompactTextString(m) } +func (*SimulateTradeRequest) ProtoMessage() {} +func (*SimulateTradeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{49} +} +func (m *SimulateTradeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SimulateTradeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SimulateTradeRequest.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 *SimulateTradeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SimulateTradeRequest.Merge(m, src) +} +func (m *SimulateTradeRequest) XXX_Size() int { + return m.Size() +} +func (m *SimulateTradeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SimulateTradeRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SimulateTradeRequest proto.InternalMessageInfo + +func (m *SimulateTradeRequest) GetInput() *v1alpha14.Value { + if m != nil { + return m.Input + } + return nil +} + +func (m *SimulateTradeRequest) GetOutput() *v1alpha14.AssetId { + if m != nil { + return m.Output + } + return nil +} + +func (m *SimulateTradeRequest) GetRouting() *SimulateTradeRequest_Routing { + if m != nil { + return m.Routing + } + return nil +} + +type SimulateTradeRequest_Routing struct { + // Types that are valid to be assigned to Setting: + // + // *SimulateTradeRequest_Routing_Default_ + // *SimulateTradeRequest_Routing_SingleHop_ + Setting isSimulateTradeRequest_Routing_Setting `protobuf_oneof:"setting"` +} + +func (m *SimulateTradeRequest_Routing) Reset() { *m = SimulateTradeRequest_Routing{} } +func (m *SimulateTradeRequest_Routing) String() string { return proto.CompactTextString(m) } +func (*SimulateTradeRequest_Routing) ProtoMessage() {} +func (*SimulateTradeRequest_Routing) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{49, 0} +} +func (m *SimulateTradeRequest_Routing) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SimulateTradeRequest_Routing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SimulateTradeRequest_Routing.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 *SimulateTradeRequest_Routing) XXX_Merge(src proto.Message) { + xxx_messageInfo_SimulateTradeRequest_Routing.Merge(m, src) +} +func (m *SimulateTradeRequest_Routing) XXX_Size() int { + return m.Size() +} +func (m *SimulateTradeRequest_Routing) XXX_DiscardUnknown() { + xxx_messageInfo_SimulateTradeRequest_Routing.DiscardUnknown(m) +} + +var xxx_messageInfo_SimulateTradeRequest_Routing proto.InternalMessageInfo + +type isSimulateTradeRequest_Routing_Setting interface { + isSimulateTradeRequest_Routing_Setting() + MarshalTo([]byte) (int, error) + Size() int +} + +type SimulateTradeRequest_Routing_Default_ struct { + Default *SimulateTradeRequest_Routing_Default `protobuf:"bytes,1,opt,name=default,proto3,oneof" json:"default,omitempty"` +} +type SimulateTradeRequest_Routing_SingleHop_ struct { + SingleHop *SimulateTradeRequest_Routing_SingleHop `protobuf:"bytes,2,opt,name=single_hop,json=singleHop,proto3,oneof" json:"single_hop,omitempty"` +} + +func (*SimulateTradeRequest_Routing_Default_) isSimulateTradeRequest_Routing_Setting() {} +func (*SimulateTradeRequest_Routing_SingleHop_) isSimulateTradeRequest_Routing_Setting() {} + +func (m *SimulateTradeRequest_Routing) GetSetting() isSimulateTradeRequest_Routing_Setting { + if m != nil { + return m.Setting + } + return nil +} + +func (m *SimulateTradeRequest_Routing) GetDefault() *SimulateTradeRequest_Routing_Default { + if x, ok := m.GetSetting().(*SimulateTradeRequest_Routing_Default_); ok { + return x.Default + } + return nil +} + +func (m *SimulateTradeRequest_Routing) GetSingleHop() *SimulateTradeRequest_Routing_SingleHop { + if x, ok := m.GetSetting().(*SimulateTradeRequest_Routing_SingleHop_); ok { + return x.SingleHop + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*SimulateTradeRequest_Routing) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*SimulateTradeRequest_Routing_Default_)(nil), + (*SimulateTradeRequest_Routing_SingleHop_)(nil), + } +} + +type SimulateTradeRequest_Routing_SingleHop struct { +} + +func (m *SimulateTradeRequest_Routing_SingleHop) Reset() { + *m = SimulateTradeRequest_Routing_SingleHop{} +} +func (m *SimulateTradeRequest_Routing_SingleHop) String() string { return proto.CompactTextString(m) } +func (*SimulateTradeRequest_Routing_SingleHop) ProtoMessage() {} +func (*SimulateTradeRequest_Routing_SingleHop) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{49, 0, 0} +} +func (m *SimulateTradeRequest_Routing_SingleHop) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SimulateTradeRequest_Routing_SingleHop) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SimulateTradeRequest_Routing_SingleHop.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 *SimulateTradeRequest_Routing_SingleHop) XXX_Merge(src proto.Message) { + xxx_messageInfo_SimulateTradeRequest_Routing_SingleHop.Merge(m, src) +} +func (m *SimulateTradeRequest_Routing_SingleHop) XXX_Size() int { + return m.Size() +} +func (m *SimulateTradeRequest_Routing_SingleHop) XXX_DiscardUnknown() { + xxx_messageInfo_SimulateTradeRequest_Routing_SingleHop.DiscardUnknown(m) +} + +var xxx_messageInfo_SimulateTradeRequest_Routing_SingleHop proto.InternalMessageInfo + +type SimulateTradeRequest_Routing_Default struct { +} + +func (m *SimulateTradeRequest_Routing_Default) Reset() { *m = SimulateTradeRequest_Routing_Default{} } +func (m *SimulateTradeRequest_Routing_Default) String() string { return proto.CompactTextString(m) } +func (*SimulateTradeRequest_Routing_Default) ProtoMessage() {} +func (*SimulateTradeRequest_Routing_Default) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{49, 0, 1} +} +func (m *SimulateTradeRequest_Routing_Default) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SimulateTradeRequest_Routing_Default) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SimulateTradeRequest_Routing_Default.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 *SimulateTradeRequest_Routing_Default) XXX_Merge(src proto.Message) { + xxx_messageInfo_SimulateTradeRequest_Routing_Default.Merge(m, src) +} +func (m *SimulateTradeRequest_Routing_Default) XXX_Size() int { + return m.Size() +} +func (m *SimulateTradeRequest_Routing_Default) XXX_DiscardUnknown() { + xxx_messageInfo_SimulateTradeRequest_Routing_Default.DiscardUnknown(m) +} + +var xxx_messageInfo_SimulateTradeRequest_Routing_Default proto.InternalMessageInfo + +type SimulateTradeResponse struct { + Output *SwapExecution `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"` +} + +func (m *SimulateTradeResponse) Reset() { *m = SimulateTradeResponse{} } +func (m *SimulateTradeResponse) String() string { return proto.CompactTextString(m) } +func (*SimulateTradeResponse) ProtoMessage() {} +func (*SimulateTradeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{50} +} +func (m *SimulateTradeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SimulateTradeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SimulateTradeResponse.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 *SimulateTradeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SimulateTradeResponse.Merge(m, src) +} +func (m *SimulateTradeResponse) XXX_Size() int { + return m.Size() +} +func (m *SimulateTradeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SimulateTradeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SimulateTradeResponse proto.InternalMessageInfo + +func (m *SimulateTradeResponse) GetOutput() *SwapExecution { + if m != nil { + return m.Output + } + return nil +} + +type EventSwap struct { + // The trading pair to swap. + TradingPair *TradingPair `protobuf:"bytes,1,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` + // The amount for asset 1. + Delta_1I *v1alpha13.Amount `protobuf:"bytes,2,opt,name=delta_1_i,json=delta1I,proto3" json:"delta_1_i,omitempty"` + // The amount for asset 2. + Delta_2I *v1alpha13.Amount `protobuf:"bytes,3,opt,name=delta_2_i,json=delta2I,proto3" json:"delta_2_i,omitempty"` + // The swap commitment. + SwapCommitment *v1alpha12.StateCommitment `protobuf:"bytes,4,opt,name=swap_commitment,json=swapCommitment,proto3" json:"swap_commitment,omitempty"` +} + +func (m *EventSwap) Reset() { *m = EventSwap{} } +func (m *EventSwap) String() string { return proto.CompactTextString(m) } +func (*EventSwap) ProtoMessage() {} +func (*EventSwap) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{51} +} +func (m *EventSwap) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventSwap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventSwap.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 *EventSwap) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventSwap.Merge(m, src) +} +func (m *EventSwap) XXX_Size() int { + return m.Size() +} +func (m *EventSwap) XXX_DiscardUnknown() { + xxx_messageInfo_EventSwap.DiscardUnknown(m) +} + +var xxx_messageInfo_EventSwap proto.InternalMessageInfo + +func (m *EventSwap) GetTradingPair() *TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +func (m *EventSwap) GetDelta_1I() *v1alpha13.Amount { + if m != nil { + return m.Delta_1I + } + return nil +} + +func (m *EventSwap) GetDelta_2I() *v1alpha13.Amount { + if m != nil { + return m.Delta_2I + } + return nil +} + +func (m *EventSwap) GetSwapCommitment() *v1alpha12.StateCommitment { + if m != nil { + return m.SwapCommitment + } + return nil +} + +type EventSwapClaim struct { + // The trading pair that is subject of the swap claim. + TradingPair *TradingPair `protobuf:"bytes,1,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` + // Note commitment for the first asset. + Output_1Commitment *v1alpha12.StateCommitment `protobuf:"bytes,2,opt,name=output_1_commitment,json=output1Commitment,proto3" json:"output_1_commitment,omitempty"` + // Note commitment for the second asset. + Output_2Commitment *v1alpha12.StateCommitment `protobuf:"bytes,3,opt,name=output_2_commitment,json=output2Commitment,proto3" json:"output_2_commitment,omitempty"` + // The nullifier for the swap commitment. + Nullifier *v1alpha1.Nullifier `protobuf:"bytes,4,opt,name=nullifier,proto3" json:"nullifier,omitempty"` +} + +func (m *EventSwapClaim) Reset() { *m = EventSwapClaim{} } +func (m *EventSwapClaim) String() string { return proto.CompactTextString(m) } +func (*EventSwapClaim) ProtoMessage() {} +func (*EventSwapClaim) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{52} +} +func (m *EventSwapClaim) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventSwapClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventSwapClaim.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 *EventSwapClaim) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventSwapClaim.Merge(m, src) +} +func (m *EventSwapClaim) XXX_Size() int { + return m.Size() +} +func (m *EventSwapClaim) XXX_DiscardUnknown() { + xxx_messageInfo_EventSwapClaim.DiscardUnknown(m) +} + +var xxx_messageInfo_EventSwapClaim proto.InternalMessageInfo + +func (m *EventSwapClaim) GetTradingPair() *TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +func (m *EventSwapClaim) GetOutput_1Commitment() *v1alpha12.StateCommitment { + if m != nil { + return m.Output_1Commitment + } + return nil +} + +func (m *EventSwapClaim) GetOutput_2Commitment() *v1alpha12.StateCommitment { + if m != nil { + return m.Output_2Commitment + } + return nil +} + +func (m *EventSwapClaim) GetNullifier() *v1alpha1.Nullifier { + if m != nil { + return m.Nullifier + } + return nil +} + +type EventPositionOpen struct { + // Position ID. + PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // The trading pair to open. + TradingPair *TradingPair `protobuf:"bytes,2,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` + // The amount for asset 1. + Reserves_1 *v1alpha13.Amount `protobuf:"bytes,3,opt,name=reserves_1,json=reserves1,proto3" json:"reserves_1,omitempty"` + // The amount for asset 2. + Reserves_2 *v1alpha13.Amount `protobuf:"bytes,4,opt,name=reserves_2,json=reserves2,proto3" json:"reserves_2,omitempty"` + // The trading fee for the position, expressed in basis points. + // e.g. 2% fee is expressed as 200, 100% fee is expressed as 10000; + TradingFee uint32 `protobuf:"varint,5,opt,name=trading_fee,json=tradingFee,proto3" json:"trading_fee,omitempty"` +} + +func (m *EventPositionOpen) Reset() { *m = EventPositionOpen{} } +func (m *EventPositionOpen) String() string { return proto.CompactTextString(m) } +func (*EventPositionOpen) ProtoMessage() {} +func (*EventPositionOpen) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{53} +} +func (m *EventPositionOpen) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventPositionOpen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventPositionOpen.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 *EventPositionOpen) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventPositionOpen.Merge(m, src) +} +func (m *EventPositionOpen) XXX_Size() int { + return m.Size() +} +func (m *EventPositionOpen) XXX_DiscardUnknown() { + xxx_messageInfo_EventPositionOpen.DiscardUnknown(m) +} + +var xxx_messageInfo_EventPositionOpen proto.InternalMessageInfo + +func (m *EventPositionOpen) GetPositionId() *PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +func (m *EventPositionOpen) GetTradingPair() *TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +func (m *EventPositionOpen) GetReserves_1() *v1alpha13.Amount { + if m != nil { + return m.Reserves_1 + } + return nil +} + +func (m *EventPositionOpen) GetReserves_2() *v1alpha13.Amount { + if m != nil { + return m.Reserves_2 + } + return nil +} + +func (m *EventPositionOpen) GetTradingFee() uint32 { + if m != nil { + return m.TradingFee + } + return 0 +} + +type EventPositionClose struct { + // The ID of the closed position + PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` +} + +func (m *EventPositionClose) Reset() { *m = EventPositionClose{} } +func (m *EventPositionClose) String() string { return proto.CompactTextString(m) } +func (*EventPositionClose) ProtoMessage() {} +func (*EventPositionClose) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{54} +} +func (m *EventPositionClose) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventPositionClose) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventPositionClose.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 *EventPositionClose) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventPositionClose.Merge(m, src) +} +func (m *EventPositionClose) XXX_Size() int { + return m.Size() +} +func (m *EventPositionClose) XXX_DiscardUnknown() { + xxx_messageInfo_EventPositionClose.DiscardUnknown(m) +} + +var xxx_messageInfo_EventPositionClose proto.InternalMessageInfo + +func (m *EventPositionClose) GetPositionId() *PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +type EventPositionWithdraw struct { + // The ID of the withdrawn position. + PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // The trading pair of the withdrawn position. + TradingPair *TradingPair `protobuf:"bytes,2,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` + // The reserves of asset 1 of the withdrawn position. + Reserves_1 *v1alpha13.Amount `protobuf:"bytes,3,opt,name=reserves_1,json=reserves1,proto3" json:"reserves_1,omitempty"` + // The reserves of asset 2 of the withdrawn position. + Reserves_2 *v1alpha13.Amount `protobuf:"bytes,4,opt,name=reserves_2,json=reserves2,proto3" json:"reserves_2,omitempty"` +} + +func (m *EventPositionWithdraw) Reset() { *m = EventPositionWithdraw{} } +func (m *EventPositionWithdraw) String() string { return proto.CompactTextString(m) } +func (*EventPositionWithdraw) ProtoMessage() {} +func (*EventPositionWithdraw) Descriptor() ([]byte, []int) { + return fileDescriptor_259f31b405eaa9a9, []int{55} +} +func (m *EventPositionWithdraw) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventPositionWithdraw) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventPositionWithdraw.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 *EventPositionWithdraw) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventPositionWithdraw.Merge(m, src) +} +func (m *EventPositionWithdraw) XXX_Size() int { + return m.Size() +} +func (m *EventPositionWithdraw) XXX_DiscardUnknown() { + xxx_messageInfo_EventPositionWithdraw.DiscardUnknown(m) +} + +var xxx_messageInfo_EventPositionWithdraw proto.InternalMessageInfo + +func (m *EventPositionWithdraw) GetPositionId() *PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +func (m *EventPositionWithdraw) GetTradingPair() *TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + +func (m *EventPositionWithdraw) GetReserves_1() *v1alpha13.Amount { + if m != nil { + return m.Reserves_1 + } + return nil +} + +func (m *EventPositionWithdraw) GetReserves_2() *v1alpha13.Amount { + if m != nil { + return m.Reserves_2 + } + return nil +} + +func init() { + proto.RegisterEnum("penumbra.core.component.dex.v1alpha1.PositionState_PositionStateEnum", PositionState_PositionStateEnum_name, PositionState_PositionStateEnum_value) + proto.RegisterType((*ZKSwapProof)(nil), "penumbra.core.component.dex.v1alpha1.ZKSwapProof") + proto.RegisterType((*ZKSwapClaimProof)(nil), "penumbra.core.component.dex.v1alpha1.ZKSwapClaimProof") + proto.RegisterType((*Swap)(nil), "penumbra.core.component.dex.v1alpha1.Swap") + proto.RegisterType((*SwapClaim)(nil), "penumbra.core.component.dex.v1alpha1.SwapClaim") + proto.RegisterType((*SwapClaimBody)(nil), "penumbra.core.component.dex.v1alpha1.SwapClaimBody") + proto.RegisterType((*SwapBody)(nil), "penumbra.core.component.dex.v1alpha1.SwapBody") + proto.RegisterType((*SwapPayload)(nil), "penumbra.core.component.dex.v1alpha1.SwapPayload") + proto.RegisterType((*SwapPlaintext)(nil), "penumbra.core.component.dex.v1alpha1.SwapPlaintext") + proto.RegisterType((*SwapPlan)(nil), "penumbra.core.component.dex.v1alpha1.SwapPlan") + proto.RegisterType((*SwapClaimPlan)(nil), "penumbra.core.component.dex.v1alpha1.SwapClaimPlan") + proto.RegisterType((*SwapView)(nil), "penumbra.core.component.dex.v1alpha1.SwapView") + proto.RegisterType((*SwapView_Visible)(nil), "penumbra.core.component.dex.v1alpha1.SwapView.Visible") + proto.RegisterType((*SwapView_Opaque)(nil), "penumbra.core.component.dex.v1alpha1.SwapView.Opaque") + proto.RegisterType((*SwapClaimView)(nil), "penumbra.core.component.dex.v1alpha1.SwapClaimView") + proto.RegisterType((*SwapClaimView_Visible)(nil), "penumbra.core.component.dex.v1alpha1.SwapClaimView.Visible") + proto.RegisterType((*SwapClaimView_Opaque)(nil), "penumbra.core.component.dex.v1alpha1.SwapClaimView.Opaque") + proto.RegisterType((*TradingPair)(nil), "penumbra.core.component.dex.v1alpha1.TradingPair") + proto.RegisterType((*DirectedTradingPair)(nil), "penumbra.core.component.dex.v1alpha1.DirectedTradingPair") + proto.RegisterType((*BatchSwapOutputData)(nil), "penumbra.core.component.dex.v1alpha1.BatchSwapOutputData") + proto.RegisterType((*TradingFunction)(nil), "penumbra.core.component.dex.v1alpha1.TradingFunction") + proto.RegisterType((*BareTradingFunction)(nil), "penumbra.core.component.dex.v1alpha1.BareTradingFunction") + proto.RegisterType((*Reserves)(nil), "penumbra.core.component.dex.v1alpha1.Reserves") + proto.RegisterType((*Position)(nil), "penumbra.core.component.dex.v1alpha1.Position") + proto.RegisterType((*PositionId)(nil), "penumbra.core.component.dex.v1alpha1.PositionId") + proto.RegisterType((*PositionState)(nil), "penumbra.core.component.dex.v1alpha1.PositionState") + proto.RegisterType((*LpNft)(nil), "penumbra.core.component.dex.v1alpha1.LpNft") + proto.RegisterType((*PositionOpen)(nil), "penumbra.core.component.dex.v1alpha1.PositionOpen") + proto.RegisterType((*PositionClose)(nil), "penumbra.core.component.dex.v1alpha1.PositionClose") + proto.RegisterType((*PositionWithdraw)(nil), "penumbra.core.component.dex.v1alpha1.PositionWithdraw") + proto.RegisterType((*PositionRewardClaim)(nil), "penumbra.core.component.dex.v1alpha1.PositionRewardClaim") + proto.RegisterType((*SwapExecution)(nil), "penumbra.core.component.dex.v1alpha1.SwapExecution") + proto.RegisterType((*SwapExecution_Trace)(nil), "penumbra.core.component.dex.v1alpha1.SwapExecution.Trace") + proto.RegisterType((*PositionWithdrawPlan)(nil), "penumbra.core.component.dex.v1alpha1.PositionWithdrawPlan") + proto.RegisterType((*PositionRewardClaimPlan)(nil), "penumbra.core.component.dex.v1alpha1.PositionRewardClaimPlan") + proto.RegisterType((*BatchSwapOutputDataRequest)(nil), "penumbra.core.component.dex.v1alpha1.BatchSwapOutputDataRequest") + proto.RegisterType((*BatchSwapOutputDataResponse)(nil), "penumbra.core.component.dex.v1alpha1.BatchSwapOutputDataResponse") + proto.RegisterType((*SwapExecutionRequest)(nil), "penumbra.core.component.dex.v1alpha1.SwapExecutionRequest") + proto.RegisterType((*SwapExecutionResponse)(nil), "penumbra.core.component.dex.v1alpha1.SwapExecutionResponse") + proto.RegisterType((*ArbExecutionRequest)(nil), "penumbra.core.component.dex.v1alpha1.ArbExecutionRequest") + proto.RegisterType((*ArbExecutionResponse)(nil), "penumbra.core.component.dex.v1alpha1.ArbExecutionResponse") + proto.RegisterType((*SwapExecutionsRequest)(nil), "penumbra.core.component.dex.v1alpha1.SwapExecutionsRequest") + proto.RegisterType((*SwapExecutionsResponse)(nil), "penumbra.core.component.dex.v1alpha1.SwapExecutionsResponse") + proto.RegisterType((*ArbExecutionsRequest)(nil), "penumbra.core.component.dex.v1alpha1.ArbExecutionsRequest") + proto.RegisterType((*ArbExecutionsResponse)(nil), "penumbra.core.component.dex.v1alpha1.ArbExecutionsResponse") + proto.RegisterType((*LiquidityPositionsRequest)(nil), "penumbra.core.component.dex.v1alpha1.LiquidityPositionsRequest") + proto.RegisterType((*LiquidityPositionsResponse)(nil), "penumbra.core.component.dex.v1alpha1.LiquidityPositionsResponse") + proto.RegisterType((*LiquidityPositionByIdRequest)(nil), "penumbra.core.component.dex.v1alpha1.LiquidityPositionByIdRequest") + proto.RegisterType((*LiquidityPositionByIdResponse)(nil), "penumbra.core.component.dex.v1alpha1.LiquidityPositionByIdResponse") + proto.RegisterType((*LiquidityPositionsByIdRequest)(nil), "penumbra.core.component.dex.v1alpha1.LiquidityPositionsByIdRequest") + proto.RegisterType((*LiquidityPositionsByIdResponse)(nil), "penumbra.core.component.dex.v1alpha1.LiquidityPositionsByIdResponse") + proto.RegisterType((*LiquidityPositionsByPriceRequest)(nil), "penumbra.core.component.dex.v1alpha1.LiquidityPositionsByPriceRequest") + proto.RegisterType((*LiquidityPositionsByPriceResponse)(nil), "penumbra.core.component.dex.v1alpha1.LiquidityPositionsByPriceResponse") + proto.RegisterType((*SpreadRequest)(nil), "penumbra.core.component.dex.v1alpha1.SpreadRequest") + proto.RegisterType((*SpreadResponse)(nil), "penumbra.core.component.dex.v1alpha1.SpreadResponse") + proto.RegisterType((*SimulateTradeRequest)(nil), "penumbra.core.component.dex.v1alpha1.SimulateTradeRequest") + proto.RegisterType((*SimulateTradeRequest_Routing)(nil), "penumbra.core.component.dex.v1alpha1.SimulateTradeRequest.Routing") + proto.RegisterType((*SimulateTradeRequest_Routing_SingleHop)(nil), "penumbra.core.component.dex.v1alpha1.SimulateTradeRequest.Routing.SingleHop") + proto.RegisterType((*SimulateTradeRequest_Routing_Default)(nil), "penumbra.core.component.dex.v1alpha1.SimulateTradeRequest.Routing.Default") + proto.RegisterType((*SimulateTradeResponse)(nil), "penumbra.core.component.dex.v1alpha1.SimulateTradeResponse") + proto.RegisterType((*EventSwap)(nil), "penumbra.core.component.dex.v1alpha1.EventSwap") + proto.RegisterType((*EventSwapClaim)(nil), "penumbra.core.component.dex.v1alpha1.EventSwapClaim") + proto.RegisterType((*EventPositionOpen)(nil), "penumbra.core.component.dex.v1alpha1.EventPositionOpen") + proto.RegisterType((*EventPositionClose)(nil), "penumbra.core.component.dex.v1alpha1.EventPositionClose") + proto.RegisterType((*EventPositionWithdraw)(nil), "penumbra.core.component.dex.v1alpha1.EventPositionWithdraw") +} + +func init() { + proto.RegisterFile("penumbra/core/component/dex/v1alpha1/dex.proto", fileDescriptor_259f31b405eaa9a9) +} + +var fileDescriptor_259f31b405eaa9a9 = []byte{ + // 2906 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5b, 0x4f, 0x6c, 0xe3, 0xc6, + 0xd5, 0xf7, 0x50, 0xb2, 0x2d, 0x3d, 0xd9, 0x8e, 0x77, 0xec, 0xcd, 0xe7, 0x28, 0xdf, 0x7a, 0x77, + 0x99, 0xcd, 0x07, 0x7f, 0x05, 0x2a, 0xaf, 0x98, 0xa6, 0x6d, 0xec, 0xe6, 0x8f, 0x65, 0xc9, 0x6b, + 0x25, 0xbb, 0xb6, 0x42, 0x39, 0xbb, 0xc5, 0xd6, 0x09, 0x43, 0x8b, 0x23, 0x9b, 0x28, 0x45, 0x72, + 0x49, 0xca, 0x6b, 0xdf, 0x0a, 0x04, 0x01, 0x8a, 0xb4, 0x29, 0x0a, 0xf4, 0xd4, 0x1e, 0x82, 0xa2, + 0x68, 0x50, 0xa0, 0x05, 0x02, 0xe4, 0x90, 0x43, 0x81, 0x9e, 0xdb, 0xb4, 0xa7, 0x20, 0xa7, 0x5e, + 0xfa, 0x07, 0xbb, 0x97, 0x22, 0xd7, 0xf6, 0xd8, 0x43, 0xc1, 0xe1, 0x90, 0x22, 0x65, 0x6a, 0x43, + 0x4a, 0x72, 0x03, 0xe4, 0x62, 0x68, 0x86, 0xef, 0xfd, 0xe6, 0xcd, 0x7b, 0x6f, 0xde, 0xbc, 0xf7, + 0x48, 0x43, 0xc9, 0x24, 0x7a, 0xb7, 0x73, 0x60, 0xc9, 0xab, 0x2d, 0xc3, 0x22, 0xab, 0x2d, 0xa3, + 0x63, 0x1a, 0x3a, 0xd1, 0x9d, 0x55, 0x85, 0x9c, 0xac, 0x1e, 0x97, 0x65, 0xcd, 0x3c, 0x92, 0xcb, + 0xee, 0xa0, 0x64, 0x5a, 0x86, 0x63, 0xe0, 0x6b, 0x3e, 0x7d, 0xc9, 0xa5, 0x2f, 0x05, 0xf4, 0x25, + 0x97, 0xc4, 0xa7, 0x2f, 0xae, 0x44, 0x51, 0x65, 0xdb, 0x26, 0x4e, 0x0f, 0x8d, 0x0e, 0x3d, 0xbc, + 0xe2, 0xc0, 0xf5, 0xdb, 0x84, 0xf4, 0x38, 0xda, 0x84, 0x7c, 0x1e, 0xbd, 0xdd, 0x0a, 0xad, 0x60, + 0xb7, 0x7c, 0xfc, 0xca, 0x40, 0xfa, 0x23, 0x95, 0x68, 0x0a, 0x51, 0x24, 0xd3, 0x30, 0xb4, 0x10, + 0x67, 0x78, 0x9a, 0x61, 0xfc, 0x5f, 0x14, 0xe3, 0xbb, 0xe4, 0xd4, 0xee, 0x31, 0xb8, 0x23, 0x46, + 0x77, 0x2d, 0x4a, 0xa7, 0x77, 0x3b, 0x3d, 0x32, 0xbd, 0xdb, 0x39, 0x8b, 0x66, 0x9d, 0x9a, 0x8e, + 0xb1, 0xea, 0x84, 0x25, 0x77, 0x7c, 0xc9, 0xf9, 0xa7, 0xa0, 0x70, 0xf7, 0x95, 0xe6, 0x7d, 0xd9, + 0x6c, 0x58, 0x86, 0xd1, 0xc6, 0x8b, 0x30, 0xa9, 0xea, 0x3a, 0xb1, 0x96, 0xd0, 0x15, 0xb4, 0x32, + 0x23, 0x7a, 0x03, 0x7e, 0x05, 0xe6, 0x3d, 0xa2, 0x4d, 0x4d, 0x56, 0x3b, 0x8f, 0xa2, 0xfc, 0x09, + 0x82, 0xac, 0x4b, 0x88, 0x6f, 0xc0, 0xa4, 0xe9, 0xd2, 0xd1, 0xc7, 0x05, 0xa1, 0x5c, 0x4a, 0x62, + 0xd1, 0x52, 0x48, 0x14, 0xd1, 0xe3, 0xc7, 0x15, 0xc8, 0x1e, 0x18, 0xca, 0xe9, 0x52, 0x96, 0xe2, + 0x94, 0x92, 0xe1, 0xb8, 0x28, 0x15, 0x43, 0x39, 0x15, 0x29, 0x2f, 0xff, 0x47, 0x04, 0xf9, 0x40, + 0x7c, 0x7c, 0x33, 0x2a, 0xda, 0xd7, 0xd3, 0x88, 0xd6, 0x53, 0x80, 0x2f, 0xdf, 0x0d, 0x26, 0x1f, + 0x47, 0xc1, 0x9e, 0x49, 0x2e, 0x1f, 0x85, 0xea, 0x09, 0x89, 0x9f, 0x86, 0x39, 0x62, 0x1a, 0xad, + 0x23, 0x49, 0xe9, 0x5a, 0xb2, 0xa3, 0x1a, 0xfa, 0xd2, 0xf4, 0x15, 0xb4, 0x92, 0x15, 0x67, 0xe9, + 0x6c, 0x95, 0x4d, 0xf2, 0x1f, 0x65, 0x60, 0x36, 0xc2, 0x8e, 0x6f, 0x41, 0x5e, 0xef, 0x6a, 0x9a, + 0xda, 0x56, 0x99, 0x35, 0x0a, 0xc2, 0xea, 0x40, 0x31, 0x5c, 0x9f, 0x0d, 0xc4, 0xd8, 0xf1, 0xd9, + 0xc4, 0x1e, 0x02, 0x5e, 0x87, 0x4c, 0x9b, 0x10, 0xb6, 0x9f, 0xff, 0x1f, 0x08, 0xe4, 0x1e, 0x96, + 0x00, 0x68, 0x8b, 0x10, 0xd1, 0xe5, 0xc2, 0xaf, 0xc3, 0x82, 0xd1, 0x75, 0xcc, 0xae, 0x23, 0x95, + 0xa5, 0x96, 0xd1, 0xe9, 0xa8, 0x4e, 0x87, 0xe8, 0xce, 0x52, 0x86, 0x82, 0x7d, 0x35, 0x04, 0x46, + 0x9d, 0xb2, 0xe4, 0x84, 0xa5, 0x69, 0x3a, 0xb2, 0x43, 0x36, 0x03, 0x26, 0xf1, 0x82, 0x87, 0x54, + 0xee, 0x4d, 0x85, 0xe0, 0x85, 0x30, 0x7c, 0x76, 0x04, 0x78, 0x21, 0x04, 0x7f, 0x17, 0x0a, 0x0c, + 0x5e, 0x91, 0x1d, 0x79, 0x69, 0x8a, 0xc2, 0x3e, 0x97, 0xcc, 0xa4, 0x15, 0xd9, 0x69, 0x1d, 0xb9, + 0x86, 0xd9, 0xa5, 0x08, 0x55, 0xd9, 0x91, 0x45, 0x30, 0x82, 0xdf, 0xfc, 0xdb, 0x19, 0xc8, 0xf9, + 0x6e, 0x89, 0xf7, 0x60, 0xc6, 0xb1, 0x64, 0x45, 0xd5, 0x0f, 0x25, 0x53, 0x56, 0xad, 0x74, 0x87, + 0x64, 0xcf, 0xe3, 0x6c, 0xc8, 0xaa, 0x25, 0x16, 0x9c, 0xde, 0x00, 0xbf, 0x00, 0x79, 0x85, 0x68, + 0x8e, 0x2c, 0x95, 0x25, 0x95, 0xd9, 0x8f, 0xef, 0x83, 0x74, 0x03, 0x44, 0x00, 0xb4, 0xd1, 0x31, + 0xba, 0xba, 0x23, 0x4e, 0x53, 0xa6, 0x72, 0xbd, 0xc7, 0x2f, 0x48, 0x2a, 0x33, 0x59, 0x72, 0x7e, + 0xa1, 0x8e, 0x6f, 0xc3, 0x5c, 0x9b, 0x90, 0xb3, 0x86, 0xe9, 0xf7, 0x46, 0x2f, 0x32, 0x87, 0x34, + 0xa7, 0xc9, 0x7a, 0x2b, 0x6c, 0x9a, 0xd9, 0x36, 0x09, 0x0d, 0xf1, 0x2b, 0x30, 0x6d, 0xca, 0xa7, + 0x9a, 0x21, 0x2b, 0x4b, 0x93, 0x69, 0x14, 0x45, 0x63, 0x89, 0xc7, 0x28, 0xfa, 0x08, 0xfc, 0x5b, + 0x08, 0x0a, 0xa1, 0x07, 0xf8, 0x16, 0x40, 0x48, 0x60, 0x34, 0x8c, 0x27, 0x85, 0x00, 0xe8, 0x29, + 0xd6, 0x29, 0x13, 0x51, 0x24, 0xfb, 0xbe, 0x6c, 0x52, 0x43, 0xcc, 0x88, 0xb3, 0xc1, 0xac, 0xbb, + 0x38, 0xff, 0x23, 0x76, 0x8a, 0x1b, 0x9a, 0xac, 0xea, 0x0e, 0x39, 0x71, 0xbe, 0xa4, 0x2e, 0xb1, + 0x05, 0xf9, 0x96, 0x1b, 0xa8, 0x24, 0x37, 0xa4, 0x64, 0xd3, 0x86, 0x94, 0x1c, 0xe5, 0xdd, 0x22, + 0x04, 0xd7, 0x61, 0xd6, 0xc3, 0x91, 0x15, 0xc5, 0x22, 0xb6, 0xcd, 0x1c, 0xe1, 0x5a, 0x1f, 0x16, + 0xbd, 0x26, 0x7b, 0xc2, 0x78, 0xb4, 0xe2, 0x0c, 0x65, 0x65, 0x23, 0xf7, 0xe2, 0xb2, 0x6c, 0x42, + 0x14, 0x7a, 0xbc, 0x67, 0x44, 0x6f, 0xc0, 0xff, 0x05, 0x79, 0xc7, 0xb3, 0xa1, 0xc9, 0x3a, 0xbe, + 0x0b, 0x73, 0xae, 0xe9, 0x24, 0xd3, 0xb7, 0x0e, 0xb3, 0x46, 0x8a, 0xe8, 0x1e, 0x18, 0x56, 0x9c, + 0xb5, 0x23, 0x76, 0xbe, 0x0a, 0x33, 0xee, 0x21, 0x39, 0xd0, 0x54, 0xdd, 0xb5, 0x12, 0x73, 0x8f, + 0x42, 0x9b, 0x90, 0x0a, 0x9b, 0xc2, 0x2b, 0x30, 0x4f, 0xef, 0x96, 0x80, 0x48, 0xb2, 0xa8, 0xee, + 0x67, 0xc4, 0x39, 0x3a, 0xef, 0x13, 0x8a, 0x31, 0x94, 0x36, 0xd5, 0x72, 0x3f, 0x65, 0x93, 0xff, + 0x2b, 0x17, 0xba, 0x36, 0xce, 0x7d, 0x93, 0x45, 0xc8, 0x99, 0x86, 0xad, 0xd2, 0x5b, 0x8c, 0xa3, + 0xb7, 0x58, 0x30, 0xee, 0x0f, 0xb2, 0x99, 0x31, 0x06, 0xd9, 0x98, 0x3b, 0x34, 0x1b, 0x73, 0x87, + 0xc6, 0x2a, 0x78, 0x32, 0xb1, 0x82, 0xa7, 0x62, 0x15, 0xfc, 0x01, 0x8b, 0xef, 0xb7, 0x55, 0x72, + 0x1f, 0x8b, 0x30, 0x7d, 0xac, 0xda, 0xea, 0x81, 0x46, 0xd2, 0x25, 0x19, 0x3e, 0x40, 0xe9, 0xb6, + 0xc7, 0xbd, 0x3d, 0x21, 0xfa, 0x40, 0x78, 0x17, 0xa6, 0x0c, 0x53, 0xbe, 0xd7, 0xf5, 0xaf, 0xe6, + 0x67, 0x53, 0x42, 0xee, 0x52, 0xe6, 0xed, 0x09, 0x91, 0xc1, 0x14, 0xdf, 0x47, 0x30, 0xcd, 0xd6, + 0xc1, 0x2f, 0x40, 0x96, 0x06, 0x2b, 0x4f, 0xda, 0xaf, 0x24, 0x87, 0x16, 0x29, 0x5f, 0x8c, 0x33, + 0x65, 0xc6, 0xe5, 0x4c, 0xc5, 0x6d, 0x98, 0xf2, 0x64, 0x1f, 0x55, 0xca, 0x4a, 0x01, 0xf2, 0x54, + 0xca, 0x63, 0x95, 0xdc, 0xe7, 0x3f, 0xcc, 0x86, 0x4e, 0x04, 0xb5, 0xda, 0x9d, 0x7e, 0xab, 0xad, + 0xa7, 0xcc, 0xe6, 0x06, 0x99, 0x6e, 0xaf, 0xcf, 0x74, 0x6b, 0xc3, 0xe0, 0x9e, 0xb1, 0xdf, 0x5b, + 0x5c, 0xcf, 0x7e, 0x3b, 0x00, 0x74, 0x67, 0x34, 0xd2, 0x7d, 0x6e, 0x12, 0x18, 0xbf, 0x8a, 0x48, + 0x95, 0xe3, 0xe5, 0xc8, 0x4d, 0xc8, 0xf9, 0x79, 0x1c, 0x93, 0xf9, 0x9b, 0x83, 0x53, 0xca, 0x48, + 0x31, 0xd3, 0x4b, 0x2e, 0x0d, 0x87, 0xb8, 0x82, 0x8b, 0xd3, 0x2c, 0x8f, 0x0b, 0x81, 0x0a, 0xcc, + 0x3d, 0x46, 0x06, 0x15, 0x8a, 0xdf, 0x0e, 0xbc, 0x63, 0xcc, 0x3a, 0xa8, 0x5c, 0x80, 0xc7, 0x7a, + 0x78, 0x9e, 0xcf, 0xbc, 0x8b, 0xa0, 0xb0, 0x17, 0xb9, 0x5e, 0xa7, 0x69, 0x32, 0x23, 0x95, 0xd9, + 0x7a, 0x4f, 0x3f, 0x3a, 0xd5, 0xd9, 0x70, 0x87, 0x75, 0x45, 0x9c, 0xa2, 0xf3, 0xe5, 0x1e, 0xbf, + 0xc0, 0xb4, 0x9c, 0x8a, 0x5f, 0xe0, 0x7f, 0x80, 0x60, 0xa1, 0xaa, 0x5a, 0xa4, 0xe5, 0x10, 0x25, + 0x2c, 0xd7, 0x3a, 0x4c, 0xda, 0x8e, 0x6c, 0x39, 0xe9, 0xa4, 0xf2, 0x78, 0xf0, 0x37, 0x20, 0x43, + 0x74, 0x25, 0x9d, 0x40, 0x2e, 0x07, 0xff, 0x51, 0x16, 0x16, 0x62, 0x22, 0x34, 0x5e, 0x87, 0x69, + 0x96, 0x84, 0x30, 0x79, 0x92, 0xa4, 0x10, 0x53, 0x5e, 0x0a, 0xd2, 0x63, 0x16, 0x52, 0xe4, 0x2f, + 0x1e, 0xb3, 0x80, 0x9f, 0x87, 0x9c, 0x26, 0x77, 0x0e, 0x14, 0x77, 0xe9, 0x14, 0xd9, 0x8b, 0xc7, + 0x53, 0x0e, 0xb1, 0x0b, 0x2c, 0x79, 0x49, 0xc1, 0x2e, 0xe0, 0x0d, 0x80, 0xae, 0xde, 0x56, 0x35, + 0x8d, 0x28, 0x52, 0x99, 0x65, 0x2c, 0x49, 0x00, 0xf2, 0x3e, 0x57, 0x39, 0x02, 0x21, 0xb0, 0x82, + 0x24, 0x15, 0x84, 0x80, 0x1f, 0x87, 0xa9, 0x23, 0xa2, 0x1e, 0x1e, 0x39, 0xac, 0x9e, 0x64, 0xa3, + 0x33, 0x09, 0x67, 0x6e, 0x2c, 0x09, 0xa7, 0x00, 0x17, 0xbd, 0x1b, 0x98, 0xfa, 0x92, 0x0b, 0xce, + 0x16, 0xcf, 0xd3, 0xc5, 0x17, 0xe8, 0xc3, 0x26, 0x7b, 0xb6, 0x4d, 0x1f, 0xf1, 0x1f, 0x22, 0x78, + 0x8c, 0x01, 0x6e, 0x75, 0xf5, 0x16, 0xbd, 0xa2, 0xef, 0x40, 0x3e, 0x58, 0x9a, 0x79, 0x4d, 0xe2, + 0x1c, 0xc1, 0x22, 0x7d, 0x68, 0x62, 0x0f, 0x0b, 0xd7, 0x20, 0x4b, 0xb7, 0xcb, 0x0d, 0xbb, 0x5d, + 0xca, 0x4e, 0x4f, 0x5e, 0xcc, 0x4a, 0x78, 0xde, 0xab, 0x9e, 0x5d, 0x89, 0x67, 0xbd, 0x92, 0xf8, + 0x3a, 0x20, 0x33, 0x85, 0xeb, 0x22, 0xd3, 0xe5, 0xb8, 0x97, 0xc2, 0x5d, 0xd1, 0x3d, 0xde, 0x82, + 0x9c, 0x48, 0x6c, 0x62, 0x1d, 0x13, 0x1b, 0x0b, 0xc0, 0x59, 0x69, 0x0e, 0x1a, 0x67, 0x95, 0x29, + 0x4f, 0x9a, 0xf3, 0xc5, 0x59, 0x02, 0xff, 0x4b, 0x0e, 0x72, 0x0d, 0x3f, 0xa9, 0xbb, 0x01, 0x19, + 0xf3, 0x48, 0x65, 0xab, 0x3e, 0x9b, 0x4a, 0xa9, 0x81, 0x91, 0x5c, 0x04, 0x37, 0x3b, 0xd7, 0x0d, + 0xbd, 0x45, 0x58, 0x5e, 0xec, 0x0d, 0x70, 0x9d, 0xc6, 0x33, 0x87, 0xa4, 0xcb, 0x2a, 0x7c, 0xe9, + 0x68, 0xbd, 0x26, 0x7a, 0x08, 0xf8, 0x65, 0xc8, 0x59, 0x4c, 0x55, 0xe9, 0x7a, 0x4a, 0xbe, 0x82, + 0xc5, 0x80, 0x1f, 0xf3, 0x6e, 0x55, 0x62, 0xd8, 0x44, 0x32, 0x74, 0xc9, 0x3d, 0x6e, 0xf4, 0x8c, + 0xe7, 0xc4, 0x02, 0x9d, 0xdc, 0xd5, 0xb7, 0x54, 0x4d, 0xe3, 0x37, 0x01, 0x7c, 0x39, 0xea, 0x4a, + 0x7c, 0xd7, 0x0c, 0x5f, 0x86, 0x82, 0xac, 0x39, 0xd2, 0x01, 0x69, 0x1d, 0x3d, 0x23, 0x74, 0xe8, + 0xd6, 0xf3, 0x22, 0xc8, 0x9a, 0x53, 0xf1, 0x66, 0xf8, 0xdf, 0x70, 0x30, 0x1b, 0xd9, 0x0d, 0xfe, + 0x8e, 0xaf, 0x11, 0x17, 0x68, 0x4e, 0xa8, 0x0d, 0xa1, 0x91, 0xe8, 0xa8, 0xa6, 0x77, 0x3b, 0x4c, + 0x47, 0xfc, 0xef, 0x10, 0x5c, 0x38, 0xf3, 0x10, 0x3f, 0x05, 0x97, 0x1b, 0xbb, 0xcd, 0xfa, 0x5e, + 0x7d, 0x77, 0x47, 0x6a, 0xee, 0x6d, 0xec, 0xd5, 0xa4, 0xda, 0xce, 0x6b, 0xb7, 0xa4, 0xd7, 0x76, + 0x9a, 0x8d, 0xda, 0x66, 0x7d, 0xab, 0x5e, 0xab, 0xce, 0x4f, 0xe0, 0x65, 0x28, 0xc6, 0x11, 0xed, + 0x36, 0x6a, 0x3b, 0xb5, 0xea, 0x3c, 0x1a, 0xf4, 0x7c, 0xf3, 0xe6, 0x6e, 0xb3, 0x56, 0x9d, 0xe7, + 0xf0, 0x55, 0xb8, 0x14, 0xf7, 0xfc, 0x4e, 0x7d, 0x6f, 0xbb, 0x2a, 0x6e, 0xdc, 0xd9, 0x99, 0xcf, + 0xe0, 0xcb, 0xf0, 0x64, 0x3c, 0xc4, 0x46, 0xfd, 0x56, 0xad, 0x3a, 0x9f, 0xe5, 0xdf, 0x47, 0x30, + 0x79, 0xd3, 0xdc, 0x69, 0x3b, 0xf8, 0x55, 0x28, 0xf8, 0x75, 0x87, 0xa4, 0x2a, 0xcc, 0x3d, 0xaf, + 0xa7, 0xd3, 0x55, 0x5d, 0x11, 0xc1, 0xec, 0x59, 0x30, 0x70, 0x45, 0x6e, 0x54, 0x57, 0xe4, 0xef, + 0xc2, 0x8c, 0x3f, 0xbf, 0x6b, 0x12, 0xdd, 0x75, 0xcd, 0xa0, 0x6a, 0x42, 0x69, 0x5c, 0xd3, 0x47, + 0xe9, 0x55, 0x59, 0xfc, 0x41, 0xcf, 0x61, 0x36, 0x5d, 0x6f, 0x3c, 0x07, 0x55, 0xf0, 0x7f, 0x40, + 0x30, 0xef, 0x3f, 0xba, 0xa3, 0x3a, 0x47, 0x8a, 0x25, 0xdf, 0x3f, 0x0f, 0x95, 0xbf, 0x09, 0x0b, + 0xfe, 0x91, 0x0b, 0x37, 0x97, 0xb8, 0xe1, 0x9a, 0x4b, 0xd8, 0xc7, 0xea, 0xcd, 0xf1, 0x1f, 0x23, + 0x58, 0x08, 0x94, 0x48, 0xee, 0xcb, 0x96, 0xe2, 0xa5, 0xc1, 0xe7, 0xb0, 0x99, 0x37, 0x00, 0x5b, + 0x74, 0x85, 0x71, 0xec, 0xe5, 0x02, 0x83, 0x0a, 0x6d, 0xe5, 0x3d, 0x56, 0xe8, 0xd7, 0x4e, 0x48, + 0xab, 0x4b, 0x63, 0xf3, 0xab, 0x30, 0xe5, 0x58, 0x72, 0x8b, 0xd8, 0x4b, 0xe8, 0x4a, 0x26, 0xf9, + 0x3d, 0x1a, 0x01, 0x71, 0x83, 0x75, 0x8b, 0x88, 0x0c, 0x08, 0x3f, 0xe7, 0x86, 0x31, 0xb3, 0xeb, + 0xcb, 0xfd, 0xd4, 0xa3, 0xe5, 0xbe, 0x2d, 0x6b, 0x5d, 0x22, 0x7a, 0x1c, 0x78, 0x1d, 0xa6, 0xbc, + 0xd4, 0x9d, 0xc5, 0xf2, 0x44, 0xbc, 0x8c, 0xa5, 0x58, 0x81, 0x49, 0x2a, 0x88, 0x2b, 0xc0, 0xb1, + 0xfb, 0x84, 0x6d, 0x29, 0x99, 0x00, 0x94, 0x83, 0xff, 0x37, 0x82, 0xc5, 0x7e, 0xaf, 0xa5, 0x0d, + 0x91, 0xf0, 0xcd, 0x80, 0x46, 0xbc, 0x19, 0xfa, 0x1c, 0x87, 0x1b, 0x83, 0xe3, 0xf8, 0x89, 0x4b, + 0x66, 0xb4, 0xc4, 0x85, 0xc0, 0xff, 0xc4, 0x78, 0xfa, 0xb8, 0x15, 0xe0, 0xc6, 0xe0, 0x62, 0x5c, + 0xb7, 0x86, 0xdc, 0xeb, 0x12, 0xdb, 0xc1, 0x4f, 0x40, 0xae, 0x75, 0x24, 0xab, 0xc1, 0xa9, 0xca, + 0x8b, 0xd3, 0x74, 0x5c, 0x57, 0x42, 0xf9, 0x2a, 0xf7, 0xc8, 0x7c, 0x35, 0x33, 0x8e, 0x7c, 0x95, + 0xd7, 0xe0, 0xc9, 0x58, 0x31, 0x6d, 0xd3, 0xd0, 0x6d, 0x82, 0x6f, 0x41, 0x96, 0x76, 0xa9, 0xd0, + 0xa8, 0x5d, 0x2a, 0x0a, 0xc3, 0xff, 0x0a, 0xc1, 0x62, 0xe4, 0x5c, 0x8d, 0xa0, 0x8f, 0xfd, 0x58, + 0x7d, 0x24, 0x14, 0x31, 0xa6, 0x68, 0x8c, 0xea, 0xc5, 0x86, 0x8b, 0x7d, 0x82, 0x32, 0x8d, 0xf8, + 0x9d, 0x1e, 0xe2, 0x3f, 0x49, 0xdf, 0x36, 0xec, 0x81, 0xd2, 0x4e, 0x4f, 0x30, 0xe4, 0xb7, 0x61, + 0x61, 0xc3, 0x3a, 0x18, 0x83, 0x72, 0xf8, 0x77, 0x10, 0x2c, 0x46, 0xa1, 0xce, 0x5f, 0xfc, 0x81, + 0xc2, 0x7c, 0x8a, 0xfa, 0x94, 0x69, 0x27, 0xd8, 0xd9, 0x55, 0x98, 0xa1, 0x25, 0x94, 0x14, 0x81, + 0x2c, 0xd0, 0x39, 0xaf, 0x6e, 0xc2, 0x97, 0x00, 0x88, 0xae, 0xf8, 0x04, 0x19, 0x4a, 0x90, 0x27, + 0xba, 0xb2, 0x1d, 0xef, 0x20, 0xd9, 0xb1, 0x3a, 0xc8, 0x67, 0x08, 0x1e, 0xef, 0xdf, 0xd4, 0x17, + 0xa7, 0xe3, 0x73, 0x3f, 0x0d, 0x11, 0x6f, 0xfa, 0xaf, 0xd8, 0xcf, 0x2d, 0x31, 0x2f, 0xf6, 0xad, + 0xfa, 0x05, 0x3a, 0xf1, 0xeb, 0xf0, 0xc4, 0x4d, 0xf5, 0x5e, 0x57, 0x55, 0x54, 0xe7, 0xd4, 0xbf, + 0x40, 0x92, 0xe8, 0xe1, 0x69, 0x98, 0x53, 0xf5, 0x96, 0xd6, 0x55, 0x88, 0x44, 0xcb, 0x22, 0x85, + 0xfa, 0x61, 0x4e, 0x9c, 0x65, 0xb3, 0x34, 0x3b, 0x55, 0xf8, 0x37, 0xa1, 0x18, 0x07, 0xcf, 0x36, + 0x5c, 0x89, 0x84, 0xe1, 0xb4, 0x59, 0xb1, 0x17, 0x7b, 0x7f, 0x88, 0xe0, 0x7f, 0xcf, 0x2c, 0x51, + 0x39, 0xad, 0x2b, 0x09, 0x36, 0x31, 0xfe, 0xeb, 0x9c, 0x6f, 0xc1, 0xa5, 0x01, 0xd2, 0x8c, 0x71, + 0xcf, 0xef, 0xa2, 0x98, 0x55, 0xec, 0x61, 0x37, 0x9d, 0x19, 0x79, 0xd3, 0x0a, 0x2c, 0x0f, 0x12, + 0x67, 0x8c, 0xbb, 0xfe, 0x10, 0xc1, 0x95, 0xb8, 0x65, 0x1a, 0x96, 0xda, 0x22, 0x09, 0x36, 0xde, + 0x1f, 0x4b, 0xb8, 0x71, 0xc6, 0x12, 0xbc, 0x08, 0x93, 0x9a, 0xda, 0x51, 0x1d, 0xda, 0x2c, 0xc8, + 0x8a, 0xde, 0x80, 0x3f, 0x84, 0xab, 0x8f, 0x10, 0x79, 0x8c, 0xca, 0xf9, 0x1e, 0x82, 0xd9, 0xa6, + 0x69, 0x11, 0x39, 0x89, 0x0b, 0xec, 0xc5, 0x6a, 0x62, 0xd4, 0x9c, 0xeb, 0x53, 0x0e, 0xe6, 0x7c, + 0x11, 0xd8, 0xce, 0xde, 0x80, 0xc5, 0x03, 0x62, 0x3b, 0x52, 0x59, 0x72, 0x0c, 0x49, 0x90, 0x46, + 0x2c, 0x83, 0xe7, 0x5d, 0xac, 0xf2, 0x9e, 0x21, 0x04, 0xfd, 0x29, 0x1f, 0x5f, 0x70, 0xf1, 0xcb, + 0x52, 0xe4, 0xe5, 0xe4, 0x90, 0xf8, 0xc2, 0x9e, 0x51, 0x0e, 0xf0, 0x5f, 0x84, 0x4b, 0xb2, 0x69, + 0x5a, 0xc6, 0x89, 0x44, 0xda, 0x6d, 0xd2, 0x72, 0xd4, 0x63, 0x22, 0x99, 0xae, 0xed, 0xd8, 0x8e, + 0x68, 0x74, 0x47, 0xe2, 0x92, 0x47, 0x54, 0xf3, 0x69, 0xa8, 0x79, 0x5d, 0x41, 0x1f, 0x01, 0xe0, + 0x89, 0x4c, 0xa3, 0xe6, 0x00, 0x00, 0x57, 0x12, 0xfe, 0x5f, 0x19, 0x58, 0x6c, 0xaa, 0x9d, 0xae, + 0x26, 0x3b, 0xb4, 0x29, 0x19, 0x38, 0x7a, 0x50, 0xab, 0xa1, 0xd4, 0xb5, 0xda, 0xf3, 0x41, 0xad, + 0x96, 0xee, 0xed, 0x84, 0xc7, 0x84, 0xf7, 0x61, 0xda, 0x32, 0xba, 0x8e, 0xaa, 0x1f, 0xb2, 0xeb, + 0xb8, 0x92, 0xf0, 0x7e, 0x8a, 0xd9, 0x46, 0x49, 0xf4, 0x90, 0x44, 0x1f, 0x92, 0xbe, 0xfe, 0x62, + 0x93, 0xb8, 0x0d, 0xd3, 0x0a, 0x69, 0xcb, 0x5d, 0xcd, 0xdf, 0xe5, 0xcb, 0xa3, 0xaf, 0x54, 0xaa, + 0x7a, 0x88, 0xdb, 0x13, 0xa2, 0x0f, 0x8e, 0x3b, 0x00, 0xb6, 0xaa, 0x1f, 0x6a, 0x44, 0x3a, 0x32, + 0xfc, 0xa6, 0xee, 0xcd, 0x31, 0x2c, 0xd5, 0xa4, 0xa0, 0xdb, 0x86, 0xb9, 0x3d, 0x21, 0xe6, 0x6d, + 0x7f, 0x50, 0x2c, 0x40, 0x3e, 0x78, 0x52, 0xcc, 0xc3, 0x34, 0x93, 0xa8, 0x92, 0x87, 0x69, 0x9b, + 0x38, 0x2e, 0x27, 0xaf, 0xc0, 0xc5, 0x3e, 0x64, 0x76, 0xa2, 0x5e, 0x09, 0x6c, 0x37, 0x42, 0x6e, + 0xc0, 0x20, 0xf8, 0xdf, 0x72, 0x90, 0xaf, 0x1d, 0x13, 0xdd, 0xa1, 0xdf, 0xf6, 0x7d, 0x59, 0xbf, + 0x5e, 0x62, 0xaf, 0xfb, 0x46, 0xfc, 0xae, 0x8c, 0xa6, 0x66, 0xa1, 0x86, 0xcc, 0x3f, 0x39, 0x98, + 0x0b, 0x74, 0xe7, 0xb5, 0x95, 0xce, 0x47, 0x81, 0x03, 0xbe, 0xbd, 0xe3, 0xce, 0xf7, 0xdb, 0xbb, + 0xcc, 0x98, 0xbe, 0xbd, 0x8b, 0x7c, 0xc5, 0x98, 0x1d, 0xf5, 0x2b, 0x46, 0xfe, 0x21, 0x07, 0x17, + 0xa8, 0xd6, 0x23, 0x1d, 0xd6, 0x73, 0xe8, 0xe7, 0x9d, 0xcb, 0x15, 0x89, 0x37, 0x00, 0x82, 0x96, + 0x67, 0x9a, 0x57, 0x97, 0x79, 0x9f, 0xab, 0x1c, 0x81, 0x48, 0xf3, 0xfa, 0x32, 0x80, 0x10, 0xf0, + 0x65, 0xf0, 0x85, 0xa2, 0xdf, 0x6f, 0x4d, 0xd2, 0x97, 0x5a, 0xc0, 0xa6, 0xb6, 0x08, 0xe1, 0x0f, + 0x01, 0x47, 0x94, 0x7c, 0x6e, 0xad, 0xe6, 0xdf, 0x73, 0x70, 0x31, 0xb2, 0xd2, 0x79, 0xf6, 0x9b, + 0xbf, 0xc4, 0x26, 0x15, 0xfe, 0x51, 0x80, 0x99, 0x57, 0xbb, 0xc4, 0x3a, 0x6d, 0x12, 0xeb, 0x58, + 0x6d, 0x11, 0xfc, 0x33, 0x14, 0xff, 0xd2, 0xfe, 0xa5, 0xe1, 0x7b, 0x5d, 0xde, 0xe5, 0x56, 0xdc, + 0x18, 0x01, 0x81, 0x5d, 0x62, 0xdf, 0x47, 0xfd, 0xcd, 0xec, 0xb5, 0x61, 0xae, 0x31, 0x26, 0xd0, + 0xfa, 0x50, 0xbc, 0x4c, 0x94, 0xb7, 0x11, 0xcc, 0x84, 0xab, 0x71, 0x9c, 0xb0, 0x1e, 0x88, 0x69, + 0x68, 0x15, 0xd7, 0x86, 0x61, 0x65, 0x72, 0xbc, 0x8b, 0x60, 0x2e, 0xda, 0x77, 0xc1, 0xc3, 0xec, + 0xcb, 0x2f, 0xdd, 0x8b, 0xdf, 0x1a, 0x8e, 0xd9, 0x93, 0xe6, 0x3a, 0xc2, 0xef, 0x20, 0x98, 0x8d, + 0x74, 0x29, 0xf0, 0x10, 0xbb, 0xb3, 0x53, 0x9a, 0x28, 0xb6, 0x2d, 0x72, 0x1d, 0xe1, 0x9f, 0x22, + 0xc0, 0x67, 0xcb, 0x28, 0xfc, 0x62, 0x32, 0xd4, 0x81, 0xfd, 0x8d, 0xe2, 0x4b, 0xc3, 0x03, 0x04, + 0xb2, 0xfd, 0x1c, 0xc1, 0xc5, 0xd8, 0x8a, 0x1f, 0x57, 0x86, 0x44, 0x0f, 0xd5, 0xf1, 0xc5, 0xcd, + 0x91, 0x30, 0x98, 0x6f, 0xbd, 0x8f, 0xe0, 0xf1, 0xf8, 0xfa, 0x1c, 0x0f, 0x8b, 0x1f, 0x6e, 0x36, + 0x14, 0xab, 0xa3, 0x81, 0x04, 0xaa, 0xfc, 0x00, 0xc5, 0x35, 0xa3, 0x58, 0xb5, 0x8c, 0xb7, 0x86, + 0x5f, 0x25, 0xdc, 0x21, 0x28, 0xde, 0x18, 0x19, 0x27, 0x10, 0xd8, 0x86, 0x29, 0xaf, 0xe0, 0xc5, + 0x49, 0xd3, 0xf0, 0x70, 0x85, 0x5e, 0xfc, 0x5a, 0x3a, 0x26, 0x6f, 0x59, 0xe1, 0x3d, 0x04, 0x17, + 0x58, 0x6d, 0xa0, 0x1a, 0xba, 0x1f, 0xef, 0x69, 0x48, 0x0d, 0x57, 0x0c, 0x89, 0x43, 0x6a, 0x4c, + 0x01, 0x93, 0x38, 0xa4, 0xc6, 0x95, 0x28, 0x95, 0xbf, 0x71, 0x1f, 0x3f, 0x58, 0x46, 0x9f, 0x3c, + 0x58, 0x46, 0x7f, 0x7f, 0xb0, 0x8c, 0x7e, 0xfc, 0x70, 0x79, 0xe2, 0x93, 0x87, 0xcb, 0x13, 0x7f, + 0x7e, 0xb8, 0x3c, 0x01, 0x2b, 0x2d, 0xa3, 0x93, 0x08, 0xba, 0x92, 0xab, 0x92, 0x93, 0x86, 0x65, + 0x38, 0x46, 0x03, 0xdd, 0xdd, 0x3f, 0x54, 0x9d, 0xa3, 0xee, 0x81, 0x4b, 0xba, 0xda, 0x32, 0xec, + 0x8e, 0x61, 0xaf, 0x5a, 0x44, 0x93, 0x4f, 0x89, 0xb5, 0x7a, 0x2c, 0x04, 0x3f, 0x69, 0x73, 0xc3, + 0x5e, 0x4d, 0xf2, 0x2f, 0x69, 0xeb, 0x0a, 0x39, 0xf1, 0x7f, 0xff, 0x82, 0xcb, 0x36, 0x36, 0x37, + 0xab, 0xbf, 0xe6, 0xae, 0x35, 0x7c, 0xb9, 0x36, 0x5d, 0xb9, 0x36, 0x03, 0xb9, 0xaa, 0xe4, 0xa4, + 0x74, 0x9b, 0x51, 0xff, 0xa9, 0x47, 0xb6, 0xef, 0x92, 0xed, 0x07, 0x64, 0xfb, 0x55, 0x72, 0xb2, + 0xef, 0x93, 0x3d, 0xe0, 0xae, 0x27, 0x21, 0xdb, 0xbf, 0xd1, 0xa8, 0xdc, 0x22, 0x8e, 0xac, 0xc8, + 0x8e, 0xfc, 0x19, 0xb7, 0xe2, 0xb3, 0xac, 0xad, 0xb9, 0x3c, 0xee, 0x5f, 0xc6, 0xb4, 0xb6, 0x56, + 0x25, 0x27, 0x6b, 0x6b, 0x3e, 0xdb, 0xc1, 0x14, 0xfd, 0x27, 0xaf, 0x67, 0xfe, 0x13, 0x00, 0x00, + 0xff, 0xff, 0xd4, 0xd2, 0x25, 0x55, 0x80, 0x37, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + // Get the batch clearing prices for a specific block height and trading pair. + BatchSwapOutputData(ctx context.Context, in *BatchSwapOutputDataRequest, opts ...grpc.CallOption) (*BatchSwapOutputDataResponse, error) + // Get the precise swap execution used for a specific batch swap. + SwapExecution(ctx context.Context, in *SwapExecutionRequest, opts ...grpc.CallOption) (*SwapExecutionResponse, error) + // Get the precise execution used to perform on-chain arbitrage. + ArbExecution(ctx context.Context, in *ArbExecutionRequest, opts ...grpc.CallOption) (*ArbExecutionResponse, error) + // Stream all swap executions over a range of heights, optionally subscribing to future executions. + SwapExecutions(ctx context.Context, in *SwapExecutionsRequest, opts ...grpc.CallOption) (QueryService_SwapExecutionsClient, error) + // Stream all arbitrage executions over a range of heights, optionally subscribing to future executions. + ArbExecutions(ctx context.Context, in *ArbExecutionsRequest, opts ...grpc.CallOption) (QueryService_ArbExecutionsClient, error) + // Query all liquidity positions on the DEX. + LiquidityPositions(ctx context.Context, in *LiquidityPositionsRequest, opts ...grpc.CallOption) (QueryService_LiquidityPositionsClient, error) + // Query liquidity positions by ID. + // + // To get multiple positions, use `LiquidityPositionsById`. + LiquidityPositionById(ctx context.Context, in *LiquidityPositionByIdRequest, opts ...grpc.CallOption) (*LiquidityPositionByIdResponse, error) + // Query multiple liquidity positions by ID. + LiquidityPositionsById(ctx context.Context, in *LiquidityPositionsByIdRequest, opts ...grpc.CallOption) (QueryService_LiquidityPositionsByIdClient, error) + // Query liquidity positions on a specific pair, sorted by effective price. + LiquidityPositionsByPrice(ctx context.Context, in *LiquidityPositionsByPriceRequest, opts ...grpc.CallOption) (QueryService_LiquidityPositionsByPriceClient, error) + // Get the current (direct) spread on a trading pair. + // + // This method doesn't do simulation, so actually executing might result in a + // better price (if the chain takes a different route to the target asset). + Spread(ctx context.Context, in *SpreadRequest, opts ...grpc.CallOption) (*SpreadResponse, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) BatchSwapOutputData(ctx context.Context, in *BatchSwapOutputDataRequest, opts ...grpc.CallOption) (*BatchSwapOutputDataResponse, error) { + out := new(BatchSwapOutputDataResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.dex.v1alpha1.QueryService/BatchSwapOutputData", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) SwapExecution(ctx context.Context, in *SwapExecutionRequest, opts ...grpc.CallOption) (*SwapExecutionResponse, error) { + out := new(SwapExecutionResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.dex.v1alpha1.QueryService/SwapExecution", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) ArbExecution(ctx context.Context, in *ArbExecutionRequest, opts ...grpc.CallOption) (*ArbExecutionResponse, error) { + out := new(ArbExecutionResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.dex.v1alpha1.QueryService/ArbExecution", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) SwapExecutions(ctx context.Context, in *SwapExecutionsRequest, opts ...grpc.CallOption) (QueryService_SwapExecutionsClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.core.component.dex.v1alpha1.QueryService/SwapExecutions", opts...) + if err != nil { + return nil, err + } + x := &queryServiceSwapExecutionsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_SwapExecutionsClient interface { + Recv() (*SwapExecutionsResponse, error) + grpc.ClientStream +} + +type queryServiceSwapExecutionsClient struct { + grpc.ClientStream +} + +func (x *queryServiceSwapExecutionsClient) Recv() (*SwapExecutionsResponse, error) { + m := new(SwapExecutionsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *queryServiceClient) ArbExecutions(ctx context.Context, in *ArbExecutionsRequest, opts ...grpc.CallOption) (QueryService_ArbExecutionsClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[1], "/penumbra.core.component.dex.v1alpha1.QueryService/ArbExecutions", opts...) + if err != nil { + return nil, err + } + x := &queryServiceArbExecutionsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_ArbExecutionsClient interface { + Recv() (*ArbExecutionsResponse, error) + grpc.ClientStream +} + +type queryServiceArbExecutionsClient struct { + grpc.ClientStream +} + +func (x *queryServiceArbExecutionsClient) Recv() (*ArbExecutionsResponse, error) { + m := new(ArbExecutionsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *queryServiceClient) LiquidityPositions(ctx context.Context, in *LiquidityPositionsRequest, opts ...grpc.CallOption) (QueryService_LiquidityPositionsClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[2], "/penumbra.core.component.dex.v1alpha1.QueryService/LiquidityPositions", opts...) + if err != nil { + return nil, err + } + x := &queryServiceLiquidityPositionsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_LiquidityPositionsClient interface { + Recv() (*LiquidityPositionsResponse, error) + grpc.ClientStream +} + +type queryServiceLiquidityPositionsClient struct { + grpc.ClientStream +} + +func (x *queryServiceLiquidityPositionsClient) Recv() (*LiquidityPositionsResponse, error) { + m := new(LiquidityPositionsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *queryServiceClient) LiquidityPositionById(ctx context.Context, in *LiquidityPositionByIdRequest, opts ...grpc.CallOption) (*LiquidityPositionByIdResponse, error) { + out := new(LiquidityPositionByIdResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.dex.v1alpha1.QueryService/LiquidityPositionById", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) LiquidityPositionsById(ctx context.Context, in *LiquidityPositionsByIdRequest, opts ...grpc.CallOption) (QueryService_LiquidityPositionsByIdClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[3], "/penumbra.core.component.dex.v1alpha1.QueryService/LiquidityPositionsById", opts...) + if err != nil { + return nil, err + } + x := &queryServiceLiquidityPositionsByIdClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_LiquidityPositionsByIdClient interface { + Recv() (*LiquidityPositionsByIdResponse, error) + grpc.ClientStream +} + +type queryServiceLiquidityPositionsByIdClient struct { + grpc.ClientStream +} + +func (x *queryServiceLiquidityPositionsByIdClient) Recv() (*LiquidityPositionsByIdResponse, error) { + m := new(LiquidityPositionsByIdResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *queryServiceClient) LiquidityPositionsByPrice(ctx context.Context, in *LiquidityPositionsByPriceRequest, opts ...grpc.CallOption) (QueryService_LiquidityPositionsByPriceClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[4], "/penumbra.core.component.dex.v1alpha1.QueryService/LiquidityPositionsByPrice", opts...) + if err != nil { + return nil, err + } + x := &queryServiceLiquidityPositionsByPriceClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_LiquidityPositionsByPriceClient interface { + Recv() (*LiquidityPositionsByPriceResponse, error) + grpc.ClientStream +} + +type queryServiceLiquidityPositionsByPriceClient struct { + grpc.ClientStream +} + +func (x *queryServiceLiquidityPositionsByPriceClient) Recv() (*LiquidityPositionsByPriceResponse, error) { + m := new(LiquidityPositionsByPriceResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *queryServiceClient) Spread(ctx context.Context, in *SpreadRequest, opts ...grpc.CallOption) (*SpreadResponse, error) { + out := new(SpreadResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.dex.v1alpha1.QueryService/Spread", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + // Get the batch clearing prices for a specific block height and trading pair. + BatchSwapOutputData(context.Context, *BatchSwapOutputDataRequest) (*BatchSwapOutputDataResponse, error) + // Get the precise swap execution used for a specific batch swap. + SwapExecution(context.Context, *SwapExecutionRequest) (*SwapExecutionResponse, error) + // Get the precise execution used to perform on-chain arbitrage. + ArbExecution(context.Context, *ArbExecutionRequest) (*ArbExecutionResponse, error) + // Stream all swap executions over a range of heights, optionally subscribing to future executions. + SwapExecutions(*SwapExecutionsRequest, QueryService_SwapExecutionsServer) error + // Stream all arbitrage executions over a range of heights, optionally subscribing to future executions. + ArbExecutions(*ArbExecutionsRequest, QueryService_ArbExecutionsServer) error + // Query all liquidity positions on the DEX. + LiquidityPositions(*LiquidityPositionsRequest, QueryService_LiquidityPositionsServer) error + // Query liquidity positions by ID. + // + // To get multiple positions, use `LiquidityPositionsById`. + LiquidityPositionById(context.Context, *LiquidityPositionByIdRequest) (*LiquidityPositionByIdResponse, error) + // Query multiple liquidity positions by ID. + LiquidityPositionsById(*LiquidityPositionsByIdRequest, QueryService_LiquidityPositionsByIdServer) error + // Query liquidity positions on a specific pair, sorted by effective price. + LiquidityPositionsByPrice(*LiquidityPositionsByPriceRequest, QueryService_LiquidityPositionsByPriceServer) error + // Get the current (direct) spread on a trading pair. + // + // This method doesn't do simulation, so actually executing might result in a + // better price (if the chain takes a different route to the target asset). + Spread(context.Context, *SpreadRequest) (*SpreadResponse, error) +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) BatchSwapOutputData(ctx context.Context, req *BatchSwapOutputDataRequest) (*BatchSwapOutputDataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method BatchSwapOutputData not implemented") +} +func (*UnimplementedQueryServiceServer) SwapExecution(ctx context.Context, req *SwapExecutionRequest) (*SwapExecutionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SwapExecution not implemented") +} +func (*UnimplementedQueryServiceServer) ArbExecution(ctx context.Context, req *ArbExecutionRequest) (*ArbExecutionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ArbExecution not implemented") +} +func (*UnimplementedQueryServiceServer) SwapExecutions(req *SwapExecutionsRequest, srv QueryService_SwapExecutionsServer) error { + return status.Errorf(codes.Unimplemented, "method SwapExecutions not implemented") +} +func (*UnimplementedQueryServiceServer) ArbExecutions(req *ArbExecutionsRequest, srv QueryService_ArbExecutionsServer) error { + return status.Errorf(codes.Unimplemented, "method ArbExecutions not implemented") +} +func (*UnimplementedQueryServiceServer) LiquidityPositions(req *LiquidityPositionsRequest, srv QueryService_LiquidityPositionsServer) error { + return status.Errorf(codes.Unimplemented, "method LiquidityPositions not implemented") +} +func (*UnimplementedQueryServiceServer) LiquidityPositionById(ctx context.Context, req *LiquidityPositionByIdRequest) (*LiquidityPositionByIdResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LiquidityPositionById not implemented") +} +func (*UnimplementedQueryServiceServer) LiquidityPositionsById(req *LiquidityPositionsByIdRequest, srv QueryService_LiquidityPositionsByIdServer) error { + return status.Errorf(codes.Unimplemented, "method LiquidityPositionsById not implemented") +} +func (*UnimplementedQueryServiceServer) LiquidityPositionsByPrice(req *LiquidityPositionsByPriceRequest, srv QueryService_LiquidityPositionsByPriceServer) error { + return status.Errorf(codes.Unimplemented, "method LiquidityPositionsByPrice not implemented") +} +func (*UnimplementedQueryServiceServer) Spread(ctx context.Context, req *SpreadRequest) (*SpreadResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Spread not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_BatchSwapOutputData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BatchSwapOutputDataRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).BatchSwapOutputData(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.dex.v1alpha1.QueryService/BatchSwapOutputData", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).BatchSwapOutputData(ctx, req.(*BatchSwapOutputDataRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_SwapExecution_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SwapExecutionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).SwapExecution(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.dex.v1alpha1.QueryService/SwapExecution", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).SwapExecution(ctx, req.(*SwapExecutionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_ArbExecution_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ArbExecutionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).ArbExecution(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.dex.v1alpha1.QueryService/ArbExecution", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).ArbExecution(ctx, req.(*ArbExecutionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_SwapExecutions_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SwapExecutionsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).SwapExecutions(m, &queryServiceSwapExecutionsServer{stream}) +} + +type QueryService_SwapExecutionsServer interface { + Send(*SwapExecutionsResponse) error + grpc.ServerStream +} + +type queryServiceSwapExecutionsServer struct { + grpc.ServerStream +} + +func (x *queryServiceSwapExecutionsServer) Send(m *SwapExecutionsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_ArbExecutions_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(ArbExecutionsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).ArbExecutions(m, &queryServiceArbExecutionsServer{stream}) +} + +type QueryService_ArbExecutionsServer interface { + Send(*ArbExecutionsResponse) error + grpc.ServerStream +} + +type queryServiceArbExecutionsServer struct { + grpc.ServerStream +} + +func (x *queryServiceArbExecutionsServer) Send(m *ArbExecutionsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_LiquidityPositions_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(LiquidityPositionsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).LiquidityPositions(m, &queryServiceLiquidityPositionsServer{stream}) +} + +type QueryService_LiquidityPositionsServer interface { + Send(*LiquidityPositionsResponse) error + grpc.ServerStream +} + +type queryServiceLiquidityPositionsServer struct { + grpc.ServerStream +} + +func (x *queryServiceLiquidityPositionsServer) Send(m *LiquidityPositionsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_LiquidityPositionById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LiquidityPositionByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).LiquidityPositionById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.dex.v1alpha1.QueryService/LiquidityPositionById", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).LiquidityPositionById(ctx, req.(*LiquidityPositionByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_LiquidityPositionsById_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(LiquidityPositionsByIdRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).LiquidityPositionsById(m, &queryServiceLiquidityPositionsByIdServer{stream}) +} + +type QueryService_LiquidityPositionsByIdServer interface { + Send(*LiquidityPositionsByIdResponse) error + grpc.ServerStream +} + +type queryServiceLiquidityPositionsByIdServer struct { + grpc.ServerStream +} + +func (x *queryServiceLiquidityPositionsByIdServer) Send(m *LiquidityPositionsByIdResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_LiquidityPositionsByPrice_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(LiquidityPositionsByPriceRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).LiquidityPositionsByPrice(m, &queryServiceLiquidityPositionsByPriceServer{stream}) +} + +type QueryService_LiquidityPositionsByPriceServer interface { + Send(*LiquidityPositionsByPriceResponse) error + grpc.ServerStream +} + +type queryServiceLiquidityPositionsByPriceServer struct { + grpc.ServerStream +} + +func (x *queryServiceLiquidityPositionsByPriceServer) Send(m *LiquidityPositionsByPriceResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_Spread_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SpreadRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).Spread(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.dex.v1alpha1.QueryService/Spread", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).Spread(ctx, req.(*SpreadRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.dex.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "BatchSwapOutputData", + Handler: _QueryService_BatchSwapOutputData_Handler, + }, + { + MethodName: "SwapExecution", + Handler: _QueryService_SwapExecution_Handler, + }, + { + MethodName: "ArbExecution", + Handler: _QueryService_ArbExecution_Handler, + }, + { + MethodName: "LiquidityPositionById", + Handler: _QueryService_LiquidityPositionById_Handler, + }, + { + MethodName: "Spread", + Handler: _QueryService_Spread_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "SwapExecutions", + Handler: _QueryService_SwapExecutions_Handler, + ServerStreams: true, + }, + { + StreamName: "ArbExecutions", + Handler: _QueryService_ArbExecutions_Handler, + ServerStreams: true, + }, + { + StreamName: "LiquidityPositions", + Handler: _QueryService_LiquidityPositions_Handler, + ServerStreams: true, + }, + { + StreamName: "LiquidityPositionsById", + Handler: _QueryService_LiquidityPositionsById_Handler, + ServerStreams: true, + }, + { + StreamName: "LiquidityPositionsByPrice", + Handler: _QueryService_LiquidityPositionsByPrice_Handler, + ServerStreams: true, + }, + }, + Metadata: "penumbra/core/component/dex/v1alpha1/dex.proto", +} + +// SimulationServiceClient is the client API for SimulationService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type SimulationServiceClient interface { + // Simulate routing and trade execution. + SimulateTrade(ctx context.Context, in *SimulateTradeRequest, opts ...grpc.CallOption) (*SimulateTradeResponse, error) +} + +type simulationServiceClient struct { + cc grpc1.ClientConn +} + +func NewSimulationServiceClient(cc grpc1.ClientConn) SimulationServiceClient { + return &simulationServiceClient{cc} +} + +func (c *simulationServiceClient) SimulateTrade(ctx context.Context, in *SimulateTradeRequest, opts ...grpc.CallOption) (*SimulateTradeResponse, error) { + out := new(SimulateTradeResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.dex.v1alpha1.SimulationService/SimulateTrade", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// SimulationServiceServer is the server API for SimulationService service. +type SimulationServiceServer interface { + // Simulate routing and trade execution. + SimulateTrade(context.Context, *SimulateTradeRequest) (*SimulateTradeResponse, error) +} + +// UnimplementedSimulationServiceServer can be embedded to have forward compatible implementations. +type UnimplementedSimulationServiceServer struct { +} + +func (*UnimplementedSimulationServiceServer) SimulateTrade(ctx context.Context, req *SimulateTradeRequest) (*SimulateTradeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SimulateTrade not implemented") +} + +func RegisterSimulationServiceServer(s grpc1.Server, srv SimulationServiceServer) { + s.RegisterService(&_SimulationService_serviceDesc, srv) +} + +func _SimulationService_SimulateTrade_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SimulateTradeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SimulationServiceServer).SimulateTrade(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.dex.v1alpha1.SimulationService/SimulateTrade", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SimulationServiceServer).SimulateTrade(ctx, req.(*SimulateTradeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _SimulationService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.dex.v1alpha1.SimulationService", + HandlerType: (*SimulationServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "SimulateTrade", + Handler: _SimulationService_SimulateTrade_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "penumbra/core/component/dex/v1alpha1/dex.proto", +} + +func (m *ZKSwapProof) 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 *ZKSwapProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ZKSwapProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintDex(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ZKSwapClaimProof) 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 *ZKSwapClaimProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ZKSwapClaimProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintDex(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Swap) 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 *Swap) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Body != nil { + { + size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Proof != nil { + { + size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapClaim) 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 *SwapClaim) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EpochDuration != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.EpochDuration)) + i-- + dAtA[i] = 0x38 + } + if m.Body != nil { + { + size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Proof != nil { + { + size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapClaimBody) 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 *SwapClaimBody) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapClaimBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.OutputData != nil { + { + size, err := m.OutputData.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.Output_2Commitment != nil { + { + size, err := m.Output_2Commitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Output_1Commitment != nil { + { + size, err := m.Output_1Commitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Fee != nil { + { + size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Nullifier != nil { + { + size, err := m.Nullifier.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapBody) 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 *SwapBody) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Payload != nil { + { + size, err := m.Payload.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.FeeCommitment != nil { + { + size, err := m.FeeCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Delta_2I != nil { + { + size, err := m.Delta_2I.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Delta_1I != nil { + { + size, err := m.Delta_1I.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapPayload) 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 *SwapPayload) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapPayload) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.EncryptedSwap) > 0 { + i -= len(m.EncryptedSwap) + copy(dAtA[i:], m.EncryptedSwap) + i = encodeVarintDex(dAtA, i, uint64(len(m.EncryptedSwap))) + i-- + dAtA[i] = 0x12 + } + if m.Commitment != nil { + { + size, err := m.Commitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapPlaintext) 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 *SwapPlaintext) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapPlaintext) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Rseed) > 0 { + i -= len(m.Rseed) + copy(dAtA[i:], m.Rseed) + i = encodeVarintDex(dAtA, i, uint64(len(m.Rseed))) + i-- + dAtA[i] = 0x32 + } + if m.ClaimAddress != nil { + { + size, err := m.ClaimAddress.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.ClaimFee != nil { + { + size, err := m.ClaimFee.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Delta_2I != nil { + { + size, err := m.Delta_2I.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Delta_1I != nil { + { + size, err := m.Delta_1I.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapPlan) 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 *SwapPlan) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ProofBlindingS) > 0 { + i -= len(m.ProofBlindingS) + copy(dAtA[i:], m.ProofBlindingS) + i = encodeVarintDex(dAtA, i, uint64(len(m.ProofBlindingS))) + i-- + dAtA[i] = 0x22 + } + if len(m.ProofBlindingR) > 0 { + i -= len(m.ProofBlindingR) + copy(dAtA[i:], m.ProofBlindingR) + i = encodeVarintDex(dAtA, i, uint64(len(m.ProofBlindingR))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeBlinding) > 0 { + i -= len(m.FeeBlinding) + copy(dAtA[i:], m.FeeBlinding) + i = encodeVarintDex(dAtA, i, uint64(len(m.FeeBlinding))) + i-- + dAtA[i] = 0x12 + } + if m.SwapPlaintext != nil { + { + size, err := m.SwapPlaintext.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapClaimPlan) 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 *SwapClaimPlan) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ProofBlindingS) > 0 { + i -= len(m.ProofBlindingS) + copy(dAtA[i:], m.ProofBlindingS) + i = encodeVarintDex(dAtA, i, uint64(len(m.ProofBlindingS))) + i-- + dAtA[i] = 0x32 + } + if len(m.ProofBlindingR) > 0 { + i -= len(m.ProofBlindingR) + copy(dAtA[i:], m.ProofBlindingR) + i = encodeVarintDex(dAtA, i, uint64(len(m.ProofBlindingR))) + i-- + dAtA[i] = 0x2a + } + if m.EpochDuration != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.EpochDuration)) + i-- + dAtA[i] = 0x20 + } + if m.OutputData != nil { + { + size, err := m.OutputData.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Position != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Position)) + i-- + dAtA[i] = 0x10 + } + if m.SwapPlaintext != nil { + { + size, err := m.SwapPlaintext.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapView) 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 *SwapView) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapView) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SwapView != nil { + { + size := m.SwapView.Size() + i -= size + if _, err := m.SwapView.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *SwapView_Visible_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Visible != nil { + { + size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *SwapView_Opaque_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Opaque != nil { + { + size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *SwapView_Visible) 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 *SwapView_Visible) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SwapPlaintext != nil { + { + size, err := m.SwapPlaintext.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Swap != nil { + { + size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapView_Opaque) 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 *SwapView_Opaque) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Swap != nil { + { + size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapClaimView) 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 *SwapClaimView) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapClaimView) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SwapClaimView != nil { + { + size := m.SwapClaimView.Size() + i -= size + if _, err := m.SwapClaimView.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *SwapClaimView_Visible_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapClaimView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Visible != nil { + { + size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *SwapClaimView_Opaque_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapClaimView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Opaque != nil { + { + size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *SwapClaimView_Visible) 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 *SwapClaimView_Visible) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapClaimView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Output_2 != nil { + { + size, err := m.Output_2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Output_1 != nil { + { + size, err := m.Output_1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.SwapClaim != nil { + { + size, err := m.SwapClaim.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapClaimView_Opaque) 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 *SwapClaimView_Opaque) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapClaimView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SwapClaim != nil { + { + size, err := m.SwapClaim.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TradingPair) 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 *TradingPair) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TradingPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Asset_2 != nil { + { + size, err := m.Asset_2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Asset_1 != nil { + { + size, err := m.Asset_1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DirectedTradingPair) 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 *DirectedTradingPair) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DirectedTradingPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.End != nil { + { + size, err := m.End.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Start != nil { + { + size, err := m.Start.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BatchSwapOutputData) 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 *BatchSwapOutputData) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BatchSwapOutputData) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EpochStartingHeight != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.EpochStartingHeight)) + i-- + dAtA[i] = 0x48 + } + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.Height != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x38 + } + if m.Unfilled_2 != nil { + { + size, err := m.Unfilled_2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.Unfilled_1 != nil { + { + size, err := m.Unfilled_1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.Lambda_2 != nil { + { + size, err := m.Lambda_2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Lambda_1 != nil { + { + size, err := m.Lambda_1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Delta_2 != nil { + { + size, err := m.Delta_2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Delta_1 != nil { + { + size, err := m.Delta_1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TradingFunction) 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 *TradingFunction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TradingFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pair != nil { + { + size, err := m.Pair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Component != nil { + { + size, err := m.Component.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BareTradingFunction) 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 *BareTradingFunction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BareTradingFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Q != nil { + { + size, err := m.Q.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.P != nil { + { + size, err := m.P.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Fee != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Fee)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Reserves) 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 *Reserves) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Reserves) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.R2 != nil { + { + size, err := m.R2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.R1 != nil { + { + size, err := m.R1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Position) 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 *Position) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Position) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CloseOnFill { + i-- + if m.CloseOnFill { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if m.Reserves != nil { + { + size, err := m.Reserves.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.State != nil { + { + size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if len(m.Nonce) > 0 { + i -= len(m.Nonce) + copy(dAtA[i:], m.Nonce) + i = encodeVarintDex(dAtA, i, uint64(len(m.Nonce))) + i-- + dAtA[i] = 0x12 + } + if m.Phi != nil { + { + size, err := m.Phi.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PositionId) 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 *PositionId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PositionId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AltBech32M) > 0 { + i -= len(m.AltBech32M) + copy(dAtA[i:], m.AltBech32M) + i = encodeVarintDex(dAtA, i, uint64(len(m.AltBech32M))) + i-- + dAtA[i] = 0x12 + } + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintDex(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PositionState) 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 *PositionState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PositionState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.State != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *LpNft) 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 *LpNft) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LpNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.State != nil { + { + size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PositionOpen) 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 *PositionOpen) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Position != nil { + { + size, err := m.Position.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PositionClose) 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 *PositionClose) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PositionWithdraw) 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 *PositionWithdraw) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ReservesCommitment != nil { + { + size, err := m.ReservesCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PositionRewardClaim) 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 *PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RewardsCommitment != nil { + { + size, err := m.RewardsCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapExecution) 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 *SwapExecution) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Output != nil { + { + size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Input != nil { + { + size, err := m.Input.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Traces) > 0 { + for iNdEx := len(m.Traces) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Traces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *SwapExecution_Trace) 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 *SwapExecution_Trace) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapExecution_Trace) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + for iNdEx := len(m.Value) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Value[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *PositionWithdrawPlan) 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 *PositionWithdrawPlan) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PositionWithdrawPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pair != nil { + { + size, err := m.Pair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Reserves != nil { + { + size, err := m.Reserves.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PositionRewardClaimPlan) 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 *PositionRewardClaimPlan) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PositionRewardClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Reserves != nil { + { + size, err := m.Reserves.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BatchSwapOutputDataRequest) 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 *BatchSwapOutputDataRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BatchSwapOutputDataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Height != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BatchSwapOutputDataResponse) 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 *BatchSwapOutputDataResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BatchSwapOutputDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Data != nil { + { + size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapExecutionRequest) 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 *SwapExecutionRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapExecutionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Height != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapExecutionResponse) 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 *SwapExecutionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapExecutionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SwapExecution != nil { + { + size, err := m.SwapExecution.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ArbExecutionRequest) 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 *ArbExecutionRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ArbExecutionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ArbExecutionResponse) 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 *ArbExecutionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ArbExecutionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if m.SwapExecution != nil { + { + size, err := m.SwapExecution.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapExecutionsRequest) 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 *SwapExecutionsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapExecutionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.EndHeight != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.EndHeight)) + i-- + dAtA[i] = 0x18 + } + if m.StartHeight != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.StartHeight)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SwapExecutionsResponse) 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 *SwapExecutionsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapExecutionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Height != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if m.SwapExecution != nil { + { + size, err := m.SwapExecution.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ArbExecutionsRequest) 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 *ArbExecutionsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ArbExecutionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EndHeight != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.EndHeight)) + i-- + dAtA[i] = 0x18 + } + if m.StartHeight != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.StartHeight)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ArbExecutionsResponse) 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 *ArbExecutionsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ArbExecutionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if m.SwapExecution != nil { + { + size, err := m.SwapExecution.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LiquidityPositionsRequest) 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 *LiquidityPositionsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityPositionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IncludeClosed { + i-- + if m.IncludeClosed { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LiquidityPositionsResponse) 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 *LiquidityPositionsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityPositionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Data != nil { + { + size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LiquidityPositionByIdRequest) 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 *LiquidityPositionByIdRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityPositionByIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LiquidityPositionByIdResponse) 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 *LiquidityPositionByIdResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityPositionByIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Data != nil { + { + size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LiquidityPositionsByIdRequest) 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 *LiquidityPositionsByIdRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityPositionsByIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.PositionId) > 0 { + for iNdEx := len(m.PositionId) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PositionId[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LiquidityPositionsByIdResponse) 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 *LiquidityPositionsByIdResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityPositionsByIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Data != nil { + { + size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LiquidityPositionsByPriceRequest) 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 *LiquidityPositionsByPriceRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityPositionsByPriceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Limit != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.Limit)) + i-- + dAtA[i] = 0x28 + } + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LiquidityPositionsByPriceResponse) 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 *LiquidityPositionsByPriceResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityPositionsByPriceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Data != nil { + { + size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SpreadRequest) 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 *SpreadRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpreadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintDex(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SpreadResponse) 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 *SpreadResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpreadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ApproxEffectivePrice_2To_1 != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ApproxEffectivePrice_2To_1)))) + i-- + dAtA[i] = 0x21 + } + if m.ApproxEffectivePrice_1To_2 != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ApproxEffectivePrice_1To_2)))) + i-- + dAtA[i] = 0x19 + } + if m.Best_2To_1Position != nil { + { + size, err := m.Best_2To_1Position.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Best_1To_2Position != nil { + { + size, err := m.Best_1To_2Position.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SimulateTradeRequest) 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 *SimulateTradeRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SimulateTradeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Routing != nil { + { + size, err := m.Routing.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Output != nil { + { + size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Input != nil { + { + size, err := m.Input.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SimulateTradeRequest_Routing) 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 *SimulateTradeRequest_Routing) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SimulateTradeRequest_Routing) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Setting != nil { + { + size := m.Setting.Size() + i -= size + if _, err := m.Setting.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *SimulateTradeRequest_Routing_Default_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SimulateTradeRequest_Routing_Default_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Default != nil { + { + size, err := m.Default.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *SimulateTradeRequest_Routing_SingleHop_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SimulateTradeRequest_Routing_SingleHop_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.SingleHop != nil { + { + size, err := m.SingleHop.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *SimulateTradeRequest_Routing_SingleHop) 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 *SimulateTradeRequest_Routing_SingleHop) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SimulateTradeRequest_Routing_SingleHop) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *SimulateTradeRequest_Routing_Default) 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 *SimulateTradeRequest_Routing_Default) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SimulateTradeRequest_Routing_Default) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *SimulateTradeResponse) 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 *SimulateTradeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SimulateTradeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Output != nil { + { + size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventSwap) 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 *EventSwap) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventSwap) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SwapCommitment != nil { + { + size, err := m.SwapCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Delta_2I != nil { + { + size, err := m.Delta_2I.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Delta_1I != nil { + { + size, err := m.Delta_1I.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventSwapClaim) 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 *EventSwapClaim) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventSwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Nullifier != nil { + { + size, err := m.Nullifier.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Output_2Commitment != nil { + { + size, err := m.Output_2Commitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Output_1Commitment != nil { + { + size, err := m.Output_1Commitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventPositionOpen) 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 *EventPositionOpen) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventPositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TradingFee != 0 { + i = encodeVarintDex(dAtA, i, uint64(m.TradingFee)) + i-- + dAtA[i] = 0x28 + } + if m.Reserves_2 != nil { + { + size, err := m.Reserves_2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Reserves_1 != nil { + { + size, err := m.Reserves_1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventPositionClose) 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 *EventPositionClose) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventPositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventPositionWithdraw) 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 *EventPositionWithdraw) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventPositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Reserves_2 != nil { + { + size, err := m.Reserves_2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Reserves_1 != nil { + { + size, err := m.Reserves_1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.TradingPair != nil { + { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDex(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintDex(dAtA []byte, offset int, v uint64) int { + offset -= sovDex(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ZKSwapProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *ZKSwapClaimProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *Swap) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proof != nil { + l = m.Proof.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Body != nil { + l = m.Body.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proof != nil { + l = m.Proof.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Body != nil { + l = m.Body.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.EpochDuration != 0 { + n += 1 + sovDex(uint64(m.EpochDuration)) + } + return n +} + +func (m *SwapClaimBody) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Nullifier != nil { + l = m.Nullifier.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Fee != nil { + l = m.Fee.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Output_1Commitment != nil { + l = m.Output_1Commitment.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Output_2Commitment != nil { + l = m.Output_2Commitment.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.OutputData != nil { + l = m.OutputData.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapBody) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Delta_1I != nil { + l = m.Delta_1I.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Delta_2I != nil { + l = m.Delta_2I.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.FeeCommitment != nil { + l = m.FeeCommitment.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Payload != nil { + l = m.Payload.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapPayload) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Commitment != nil { + l = m.Commitment.Size() + n += 1 + l + sovDex(uint64(l)) + } + l = len(m.EncryptedSwap) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapPlaintext) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Delta_1I != nil { + l = m.Delta_1I.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Delta_2I != nil { + l = m.Delta_2I.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.ClaimFee != nil { + l = m.ClaimFee.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.ClaimAddress != nil { + l = m.ClaimAddress.Size() + n += 1 + l + sovDex(uint64(l)) + } + l = len(m.Rseed) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapPlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapPlaintext != nil { + l = m.SwapPlaintext.Size() + n += 1 + l + sovDex(uint64(l)) + } + l = len(m.FeeBlinding) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + l = len(m.ProofBlindingR) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + l = len(m.ProofBlindingS) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapClaimPlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapPlaintext != nil { + l = m.SwapPlaintext.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Position != 0 { + n += 1 + sovDex(uint64(m.Position)) + } + if m.OutputData != nil { + l = m.OutputData.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.EpochDuration != 0 { + n += 1 + sovDex(uint64(m.EpochDuration)) + } + l = len(m.ProofBlindingR) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + l = len(m.ProofBlindingS) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapView != nil { + n += m.SwapView.Size() + } + return n +} + +func (m *SwapView_Visible_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Visible != nil { + l = m.Visible.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} +func (m *SwapView_Opaque_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Opaque != nil { + l = m.Opaque.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} +func (m *SwapView_Visible) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Swap != nil { + l = m.Swap.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.SwapPlaintext != nil { + l = m.SwapPlaintext.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapView_Opaque) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Swap != nil { + l = m.Swap.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapClaimView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapClaimView != nil { + n += m.SwapClaimView.Size() + } + return n +} + +func (m *SwapClaimView_Visible_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Visible != nil { + l = m.Visible.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} +func (m *SwapClaimView_Opaque_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Opaque != nil { + l = m.Opaque.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} +func (m *SwapClaimView_Visible) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapClaim != nil { + l = m.SwapClaim.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Output_1 != nil { + l = m.Output_1.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Output_2 != nil { + l = m.Output_2.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapClaimView_Opaque) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapClaim != nil { + l = m.SwapClaim.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *TradingPair) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Asset_1 != nil { + l = m.Asset_1.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Asset_2 != nil { + l = m.Asset_2.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *DirectedTradingPair) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Start != nil { + l = m.Start.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.End != nil { + l = m.End.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *BatchSwapOutputData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Delta_1 != nil { + l = m.Delta_1.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Delta_2 != nil { + l = m.Delta_2.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Lambda_1 != nil { + l = m.Lambda_1.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Lambda_2 != nil { + l = m.Lambda_2.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Unfilled_1 != nil { + l = m.Unfilled_1.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Unfilled_2 != nil { + l = m.Unfilled_2.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovDex(uint64(m.Height)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.EpochStartingHeight != 0 { + n += 1 + sovDex(uint64(m.EpochStartingHeight)) + } + return n +} + +func (m *TradingFunction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Component != nil { + l = m.Component.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Pair != nil { + l = m.Pair.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *BareTradingFunction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Fee != 0 { + n += 1 + sovDex(uint64(m.Fee)) + } + if m.P != nil { + l = m.P.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Q != nil { + l = m.Q.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *Reserves) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.R1 != nil { + l = m.R1.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.R2 != nil { + l = m.R2.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *Position) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Phi != nil { + l = m.Phi.Size() + n += 1 + l + sovDex(uint64(l)) + } + l = len(m.Nonce) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.State != nil { + l = m.State.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Reserves != nil { + l = m.Reserves.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.CloseOnFill { + n += 2 + } + return n +} + +func (m *PositionId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + l = len(m.AltBech32M) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *PositionState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.State != 0 { + n += 1 + sovDex(uint64(m.State)) + } + return n +} + +func (m *LpNft) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.State != nil { + l = m.State.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *PositionOpen) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Position != nil { + l = m.Position.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *PositionClose) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *PositionWithdraw) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.ReservesCommitment != nil { + l = m.ReservesCommitment.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *PositionRewardClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.RewardsCommitment != nil { + l = m.RewardsCommitment.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapExecution) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Traces) > 0 { + for _, e := range m.Traces { + l = e.Size() + n += 1 + l + sovDex(uint64(l)) + } + } + if m.Input != nil { + l = m.Input.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Output != nil { + l = m.Output.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapExecution_Trace) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovDex(uint64(l)) + } + } + return n +} + +func (m *PositionWithdrawPlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Reserves != nil { + l = m.Reserves.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Pair != nil { + l = m.Pair.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *PositionRewardClaimPlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Reserves != nil { + l = m.Reserves.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *BatchSwapOutputDataRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovDex(uint64(m.Height)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *BatchSwapOutputDataResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapExecutionRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovDex(uint64(m.Height)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapExecutionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapExecution != nil { + l = m.SwapExecution.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *ArbExecutionRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovDex(uint64(m.Height)) + } + return n +} + +func (m *ArbExecutionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapExecution != nil { + l = m.SwapExecution.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovDex(uint64(m.Height)) + } + return n +} + +func (m *SwapExecutionsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.StartHeight != 0 { + n += 1 + sovDex(uint64(m.StartHeight)) + } + if m.EndHeight != 0 { + n += 1 + sovDex(uint64(m.EndHeight)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SwapExecutionsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapExecution != nil { + l = m.SwapExecution.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovDex(uint64(m.Height)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *ArbExecutionsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.StartHeight != 0 { + n += 1 + sovDex(uint64(m.StartHeight)) + } + if m.EndHeight != 0 { + n += 1 + sovDex(uint64(m.EndHeight)) + } + return n +} + +func (m *ArbExecutionsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwapExecution != nil { + l = m.SwapExecution.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovDex(uint64(m.Height)) + } + return n +} + +func (m *LiquidityPositionsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.IncludeClosed { + n += 2 + } + return n +} + +func (m *LiquidityPositionsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *LiquidityPositionByIdRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *LiquidityPositionByIdResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *LiquidityPositionsByIdRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if len(m.PositionId) > 0 { + for _, e := range m.PositionId { + l = e.Size() + n += 1 + l + sovDex(uint64(l)) + } + } + return n +} + +func (m *LiquidityPositionsByIdResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *LiquidityPositionsByPriceRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Limit != 0 { + n += 1 + sovDex(uint64(m.Limit)) + } + return n +} + +func (m *LiquidityPositionsByPriceResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SpreadRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovDex(uint64(l)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SpreadResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Best_1To_2Position != nil { + l = m.Best_1To_2Position.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Best_2To_1Position != nil { + l = m.Best_2To_1Position.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.ApproxEffectivePrice_1To_2 != 0 { + n += 9 + } + if m.ApproxEffectivePrice_2To_1 != 0 { + n += 9 + } + return n +} + +func (m *SimulateTradeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Input != nil { + l = m.Input.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Output != nil { + l = m.Output.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Routing != nil { + l = m.Routing.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *SimulateTradeRequest_Routing) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Setting != nil { + n += m.Setting.Size() + } + return n +} + +func (m *SimulateTradeRequest_Routing_Default_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Default != nil { + l = m.Default.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} +func (m *SimulateTradeRequest_Routing_SingleHop_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SingleHop != nil { + l = m.SingleHop.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} +func (m *SimulateTradeRequest_Routing_SingleHop) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *SimulateTradeRequest_Routing_Default) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *SimulateTradeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Output != nil { + l = m.Output.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *EventSwap) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Delta_1I != nil { + l = m.Delta_1I.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Delta_2I != nil { + l = m.Delta_2I.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.SwapCommitment != nil { + l = m.SwapCommitment.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *EventSwapClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Output_1Commitment != nil { + l = m.Output_1Commitment.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Output_2Commitment != nil { + l = m.Output_2Commitment.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Nullifier != nil { + l = m.Nullifier.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *EventPositionOpen) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Reserves_1 != nil { + l = m.Reserves_1.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Reserves_2 != nil { + l = m.Reserves_2.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.TradingFee != 0 { + n += 1 + sovDex(uint64(m.TradingFee)) + } + return n +} + +func (m *EventPositionClose) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func (m *EventPositionWithdraw) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Reserves_1 != nil { + l = m.Reserves_1.Size() + n += 1 + l + sovDex(uint64(l)) + } + if m.Reserves_2 != nil { + l = m.Reserves_2.Size() + n += 1 + l + sovDex(uint64(l)) + } + return n +} + +func sovDex(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozDex(x uint64) (n int) { + return sovDex(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ZKSwapProof) 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 ErrIntOverflowDex + } + 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: ZKSwapProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZKSwapProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ZKSwapClaimProof) 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 ErrIntOverflowDex + } + 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: ZKSwapClaimProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZKSwapClaimProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Swap) 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 ErrIntOverflowDex + } + 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: Swap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Swap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proof == nil { + m.Proof = &ZKSwapProof{} + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = &SwapBody{} + } + if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapClaim) 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 ErrIntOverflowDex + } + 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: SwapClaim: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapClaim: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proof == nil { + m.Proof = &ZKSwapClaimProof{} + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = &SwapClaimBody{} + } + if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochDuration", wireType) + } + m.EpochDuration = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EpochDuration |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapClaimBody) 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 ErrIntOverflowDex + } + 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: SwapClaimBody: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapClaimBody: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nullifier == nil { + m.Nullifier = &v1alpha1.Nullifier{} + } + if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Fee == nil { + m.Fee = &v1alpha11.Fee{} + } + if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output_1Commitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output_1Commitment == nil { + m.Output_1Commitment = &v1alpha12.StateCommitment{} + } + if err := m.Output_1Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output_2Commitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output_2Commitment == nil { + m.Output_2Commitment = &v1alpha12.StateCommitment{} + } + if err := m.Output_2Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.OutputData == nil { + m.OutputData = &BatchSwapOutputData{} + } + if err := m.OutputData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapBody) 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 ErrIntOverflowDex + } + 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: SwapBody: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapBody: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delta_1I", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Delta_1I == nil { + m.Delta_1I = &v1alpha13.Amount{} + } + if err := m.Delta_1I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delta_2I", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Delta_2I == nil { + m.Delta_2I = &v1alpha13.Amount{} + } + if err := m.Delta_2I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeCommitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FeeCommitment == nil { + m.FeeCommitment = &v1alpha14.BalanceCommitment{} + } + if err := m.FeeCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Payload == nil { + m.Payload = &SwapPayload{} + } + if err := m.Payload.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapPayload) 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 ErrIntOverflowDex + } + 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: SwapPayload: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapPayload: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Commitment == nil { + m.Commitment = &v1alpha12.StateCommitment{} + } + if err := m.Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EncryptedSwap", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EncryptedSwap = append(m.EncryptedSwap[:0], dAtA[iNdEx:postIndex]...) + if m.EncryptedSwap == nil { + m.EncryptedSwap = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapPlaintext) 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 ErrIntOverflowDex + } + 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: SwapPlaintext: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapPlaintext: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delta_1I", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Delta_1I == nil { + m.Delta_1I = &v1alpha13.Amount{} + } + if err := m.Delta_1I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delta_2I", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Delta_2I == nil { + m.Delta_2I = &v1alpha13.Amount{} + } + if err := m.Delta_2I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClaimFee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ClaimFee == nil { + m.ClaimFee = &v1alpha11.Fee{} + } + if err := m.ClaimFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClaimAddress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ClaimAddress == nil { + m.ClaimAddress = &v1alpha15.Address{} + } + if err := m.ClaimAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) + if m.Rseed == nil { + m.Rseed = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapPlan) 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 ErrIntOverflowDex + } + 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: SwapPlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapPlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapPlaintext", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapPlaintext == nil { + m.SwapPlaintext = &SwapPlaintext{} + } + if err := m.SwapPlaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeBlinding", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeBlinding = append(m.FeeBlinding[:0], dAtA[iNdEx:postIndex]...) + if m.FeeBlinding == nil { + m.FeeBlinding = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingR == nil { + m.ProofBlindingR = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingS == nil { + m.ProofBlindingS = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapClaimPlan) 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 ErrIntOverflowDex + } + 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: SwapClaimPlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapClaimPlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapPlaintext", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapPlaintext == nil { + m.SwapPlaintext = &SwapPlaintext{} + } + if err := m.SwapPlaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) + } + m.Position = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Position |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.OutputData == nil { + m.OutputData = &BatchSwapOutputData{} + } + if err := m.OutputData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochDuration", wireType) + } + m.EpochDuration = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EpochDuration |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingR == nil { + m.ProofBlindingR = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingS == nil { + m.ProofBlindingS = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapView) 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 ErrIntOverflowDex + } + 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: SwapView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &SwapView_Visible{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.SwapView = &SwapView_Visible_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &SwapView_Opaque{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.SwapView = &SwapView_Opaque_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapView_Visible) 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 ErrIntOverflowDex + } + 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: Visible: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Swap == nil { + m.Swap = &Swap{} + } + if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapPlaintext", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapPlaintext == nil { + m.SwapPlaintext = &SwapPlaintext{} + } + if err := m.SwapPlaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapView_Opaque) 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 ErrIntOverflowDex + } + 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: Opaque: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Swap == nil { + m.Swap = &Swap{} + } + if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapClaimView) 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 ErrIntOverflowDex + } + 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: SwapClaimView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapClaimView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &SwapClaimView_Visible{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.SwapClaimView = &SwapClaimView_Visible_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &SwapClaimView_Opaque{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.SwapClaimView = &SwapClaimView_Opaque_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapClaimView_Visible) 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 ErrIntOverflowDex + } + 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: Visible: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapClaim == nil { + m.SwapClaim = &SwapClaim{} + } + if err := m.SwapClaim.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output_1 == nil { + m.Output_1 = &v1alpha16.NoteView{} + } + if err := m.Output_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output_2 == nil { + m.Output_2 = &v1alpha16.NoteView{} + } + if err := m.Output_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapClaimView_Opaque) 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 ErrIntOverflowDex + } + 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: Opaque: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapClaim == nil { + m.SwapClaim = &SwapClaim{} + } + if err := m.SwapClaim.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TradingPair) 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 ErrIntOverflowDex + } + 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: TradingPair: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TradingPair: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Asset_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Asset_1 == nil { + m.Asset_1 = &v1alpha14.AssetId{} + } + if err := m.Asset_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Asset_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Asset_2 == nil { + m.Asset_2 = &v1alpha14.AssetId{} + } + if err := m.Asset_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DirectedTradingPair) 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 ErrIntOverflowDex + } + 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: DirectedTradingPair: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DirectedTradingPair: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Start == nil { + m.Start = &v1alpha14.AssetId{} + } + if err := m.Start.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field End", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.End == nil { + m.End = &v1alpha14.AssetId{} + } + if err := m.End.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BatchSwapOutputData) 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 ErrIntOverflowDex + } + 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: BatchSwapOutputData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BatchSwapOutputData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delta_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Delta_1 == nil { + m.Delta_1 = &v1alpha13.Amount{} + } + if err := m.Delta_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delta_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Delta_2 == nil { + m.Delta_2 = &v1alpha13.Amount{} + } + if err := m.Delta_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Lambda_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Lambda_1 == nil { + m.Lambda_1 = &v1alpha13.Amount{} + } + if err := m.Lambda_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Lambda_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Lambda_2 == nil { + m.Lambda_2 = &v1alpha13.Amount{} + } + if err := m.Lambda_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Unfilled_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Unfilled_1 == nil { + m.Unfilled_1 = &v1alpha13.Amount{} + } + if err := m.Unfilled_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Unfilled_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Unfilled_2 == nil { + m.Unfilled_2 = &v1alpha13.Amount{} + } + if err := m.Unfilled_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochStartingHeight", wireType) + } + m.EpochStartingHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EpochStartingHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TradingFunction) 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 ErrIntOverflowDex + } + 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: TradingFunction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TradingFunction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Component", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Component == nil { + m.Component = &BareTradingFunction{} + } + if err := m.Component.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pair == nil { + m.Pair = &TradingPair{} + } + if err := m.Pair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BareTradingFunction) 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 ErrIntOverflowDex + } + 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: BareTradingFunction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BareTradingFunction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) + } + m.Fee = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Fee |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field P", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.P == nil { + m.P = &v1alpha13.Amount{} + } + if err := m.P.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Q", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Q == nil { + m.Q = &v1alpha13.Amount{} + } + if err := m.Q.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Reserves) 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 ErrIntOverflowDex + } + 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: Reserves: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Reserves: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field R1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.R1 == nil { + m.R1 = &v1alpha13.Amount{} + } + if err := m.R1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field R2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.R2 == nil { + m.R2 = &v1alpha13.Amount{} + } + if err := m.R2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Position) 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 ErrIntOverflowDex + } + 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: Position: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Position: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Phi", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Phi == nil { + m.Phi = &TradingFunction{} + } + if err := m.Phi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Nonce = append(m.Nonce[:0], dAtA[iNdEx:postIndex]...) + if m.Nonce == nil { + m.Nonce = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.State == nil { + m.State = &PositionState{} + } + if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reserves", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Reserves == nil { + m.Reserves = &Reserves{} + } + if err := m.Reserves.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CloseOnFill", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CloseOnFill = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PositionId) 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 ErrIntOverflowDex + } + 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: PositionId: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PositionId: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AltBech32M", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AltBech32M = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PositionState) 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 ErrIntOverflowDex + } + 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: PositionState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PositionState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + m.State = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.State |= PositionState_PositionStateEnum(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LpNft) 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 ErrIntOverflowDex + } + 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: LpNft: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LpNft: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionId == nil { + m.PositionId = &PositionId{} + } + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.State == nil { + m.State = &PositionState{} + } + if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PositionOpen) 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 ErrIntOverflowDex + } + 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: PositionOpen: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PositionOpen: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Position == nil { + m.Position = &Position{} + } + if err := m.Position.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PositionClose) 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 ErrIntOverflowDex + } + 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: PositionClose: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PositionClose: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionId == nil { + m.PositionId = &PositionId{} + } + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PositionWithdraw) 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 ErrIntOverflowDex + } + 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: PositionWithdraw: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PositionWithdraw: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionId == nil { + m.PositionId = &PositionId{} + } + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReservesCommitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReservesCommitment == nil { + m.ReservesCommitment = &v1alpha14.BalanceCommitment{} + } + if err := m.ReservesCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PositionRewardClaim) 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 ErrIntOverflowDex + } + 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: PositionRewardClaim: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PositionRewardClaim: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionId == nil { + m.PositionId = &PositionId{} + } + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RewardsCommitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RewardsCommitment == nil { + m.RewardsCommitment = &v1alpha14.BalanceCommitment{} + } + if err := m.RewardsCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapExecution) 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 ErrIntOverflowDex + } + 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: SwapExecution: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapExecution: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Traces", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Traces = append(m.Traces, &SwapExecution_Trace{}) + if err := m.Traces[len(m.Traces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Input == nil { + m.Input = &v1alpha14.Value{} + } + if err := m.Input.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output == nil { + m.Output = &v1alpha14.Value{} + } + if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapExecution_Trace) 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 ErrIntOverflowDex + } + 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: Trace: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Trace: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value, &v1alpha14.Value{}) + if err := m.Value[len(m.Value)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PositionWithdrawPlan) 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 ErrIntOverflowDex + } + 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: PositionWithdrawPlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PositionWithdrawPlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reserves", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Reserves == nil { + m.Reserves = &Reserves{} + } + if err := m.Reserves.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionId == nil { + m.PositionId = &PositionId{} + } + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pair == nil { + m.Pair = &TradingPair{} + } + if err := m.Pair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PositionRewardClaimPlan) 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 ErrIntOverflowDex + } + 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: PositionRewardClaimPlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PositionRewardClaimPlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reserves", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Reserves == nil { + m.Reserves = &Reserves{} + } + if err := m.Reserves.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BatchSwapOutputDataRequest) 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 ErrIntOverflowDex + } + 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: BatchSwapOutputDataRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BatchSwapOutputDataRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BatchSwapOutputDataResponse) 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 ErrIntOverflowDex + } + 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: BatchSwapOutputDataResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BatchSwapOutputDataResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = &BatchSwapOutputData{} + } + if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapExecutionRequest) 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 ErrIntOverflowDex + } + 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: SwapExecutionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapExecutionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &DirectedTradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapExecutionResponse) 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 ErrIntOverflowDex + } + 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: SwapExecutionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapExecutionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapExecution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapExecution == nil { + m.SwapExecution = &SwapExecution{} + } + if err := m.SwapExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ArbExecutionRequest) 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 ErrIntOverflowDex + } + 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: ArbExecutionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ArbExecutionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ArbExecutionResponse) 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 ErrIntOverflowDex + } + 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: ArbExecutionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ArbExecutionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapExecution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapExecution == nil { + m.SwapExecution = &SwapExecution{} + } + if err := m.SwapExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapExecutionsRequest) 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 ErrIntOverflowDex + } + 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: SwapExecutionsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapExecutionsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType) + } + m.StartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndHeight", wireType) + } + m.EndHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &DirectedTradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapExecutionsResponse) 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 ErrIntOverflowDex + } + 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: SwapExecutionsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapExecutionsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapExecution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapExecution == nil { + m.SwapExecution = &SwapExecution{} + } + if err := m.SwapExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &DirectedTradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ArbExecutionsRequest) 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 ErrIntOverflowDex + } + 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: ArbExecutionsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ArbExecutionsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType) + } + m.StartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndHeight", wireType) + } + m.EndHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ArbExecutionsResponse) 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 ErrIntOverflowDex + } + 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: ArbExecutionsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ArbExecutionsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapExecution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapExecution == nil { + m.SwapExecution = &SwapExecution{} + } + if err := m.SwapExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidityPositionsRequest) 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 ErrIntOverflowDex + } + 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: LiquidityPositionsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityPositionsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IncludeClosed", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IncludeClosed = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidityPositionsResponse) 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 ErrIntOverflowDex + } + 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: LiquidityPositionsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityPositionsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = &Position{} + } + if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidityPositionByIdRequest) 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 ErrIntOverflowDex + } + 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: LiquidityPositionByIdRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityPositionByIdRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionId == nil { + m.PositionId = &PositionId{} + } + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidityPositionByIdResponse) 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 ErrIntOverflowDex + } + 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: LiquidityPositionByIdResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityPositionByIdResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = &Position{} + } + if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidityPositionsByIdRequest) 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 ErrIntOverflowDex + } + 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: LiquidityPositionsByIdRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityPositionsByIdRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PositionId = append(m.PositionId, &PositionId{}) + if err := m.PositionId[len(m.PositionId)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidityPositionsByIdResponse) 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 ErrIntOverflowDex + } + 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: LiquidityPositionsByIdResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityPositionsByIdResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = &Position{} + } + if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidityPositionsByPriceRequest) 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 ErrIntOverflowDex + } + 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: LiquidityPositionsByPriceRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityPositionsByPriceRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &DirectedTradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) + } + m.Limit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Limit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidityPositionsByPriceResponse) 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 ErrIntOverflowDex + } + 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: LiquidityPositionsByPriceResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityPositionsByPriceResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = &Position{} + } + if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpreadRequest) 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 ErrIntOverflowDex + } + 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: SpreadRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpreadRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + 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 ErrInvalidLengthDex + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpreadResponse) 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 ErrIntOverflowDex + } + 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: SpreadResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpreadResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Best_1To_2Position", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Best_1To_2Position == nil { + m.Best_1To_2Position = &Position{} + } + if err := m.Best_1To_2Position.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Best_2To_1Position", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Best_2To_1Position == nil { + m.Best_2To_1Position = &Position{} + } + if err := m.Best_2To_1Position.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field ApproxEffectivePrice_1To_2", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.ApproxEffectivePrice_1To_2 = float64(math.Float64frombits(v)) + case 4: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field ApproxEffectivePrice_2To_1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.ApproxEffectivePrice_2To_1 = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SimulateTradeRequest) 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 ErrIntOverflowDex + } + 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: SimulateTradeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SimulateTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Input == nil { + m.Input = &v1alpha14.Value{} + } + if err := m.Input.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output == nil { + m.Output = &v1alpha14.AssetId{} + } + if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Routing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Routing == nil { + m.Routing = &SimulateTradeRequest_Routing{} + } + if err := m.Routing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SimulateTradeRequest_Routing) 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 ErrIntOverflowDex + } + 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: Routing: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Routing: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Default", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &SimulateTradeRequest_Routing_Default{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Setting = &SimulateTradeRequest_Routing_Default_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SingleHop", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &SimulateTradeRequest_Routing_SingleHop{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Setting = &SimulateTradeRequest_Routing_SingleHop_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SimulateTradeRequest_Routing_SingleHop) 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 ErrIntOverflowDex + } + 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: SingleHop: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SingleHop: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SimulateTradeRequest_Routing_Default) 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 ErrIntOverflowDex + } + 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: Default: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Default: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SimulateTradeResponse) 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 ErrIntOverflowDex + } + 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: SimulateTradeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SimulateTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output == nil { + m.Output = &SwapExecution{} + } + if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventSwap) 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 ErrIntOverflowDex + } + 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: EventSwap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventSwap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delta_1I", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Delta_1I == nil { + m.Delta_1I = &v1alpha13.Amount{} + } + if err := m.Delta_1I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delta_2I", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Delta_2I == nil { + m.Delta_2I = &v1alpha13.Amount{} + } + if err := m.Delta_2I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapCommitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapCommitment == nil { + m.SwapCommitment = &v1alpha12.StateCommitment{} + } + if err := m.SwapCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventSwapClaim) 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 ErrIntOverflowDex + } + 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: EventSwapClaim: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventSwapClaim: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output_1Commitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output_1Commitment == nil { + m.Output_1Commitment = &v1alpha12.StateCommitment{} + } + if err := m.Output_1Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output_2Commitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output_2Commitment == nil { + m.Output_2Commitment = &v1alpha12.StateCommitment{} + } + if err := m.Output_2Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nullifier == nil { + m.Nullifier = &v1alpha1.Nullifier{} + } + if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventPositionOpen) 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 ErrIntOverflowDex + } + 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: EventPositionOpen: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventPositionOpen: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionId == nil { + m.PositionId = &PositionId{} + } + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reserves_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Reserves_1 == nil { + m.Reserves_1 = &v1alpha13.Amount{} + } + if err := m.Reserves_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reserves_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Reserves_2 == nil { + m.Reserves_2 = &v1alpha13.Amount{} + } + if err := m.Reserves_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingFee", wireType) + } + m.TradingFee = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TradingFee |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventPositionClose) 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 ErrIntOverflowDex + } + 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: EventPositionClose: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventPositionClose: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionId == nil { + m.PositionId = &PositionId{} + } + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventPositionWithdraw) 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 ErrIntOverflowDex + } + 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: EventPositionWithdraw: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventPositionWithdraw: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionId == nil { + m.PositionId = &PositionId{} + } + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TradingPair == nil { + m.TradingPair = &TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reserves_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Reserves_1 == nil { + m.Reserves_1 = &v1alpha13.Amount{} + } + if err := m.Reserves_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reserves_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDex + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDex + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Reserves_2 == nil { + m.Reserves_2 = &v1alpha13.Amount{} + } + if err := m.Reserves_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipDex(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, ErrIntOverflowDex + } + 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, ErrIntOverflowDex + } + 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, ErrIntOverflowDex + } + 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, ErrInvalidLengthDex + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupDex + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthDex + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthDex = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDex = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupDex = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/component/distributions/v1alpha1/distributions.pb.go b/relayer/chains/penumbra/core/component/distributions/v1alpha1/distributions.pb.go new file mode 100644 index 000000000..466b5e0f1 --- /dev/null +++ b/relayer/chains/penumbra/core/component/distributions/v1alpha1/distributions.pb.go @@ -0,0 +1,496 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/distributions/v1alpha1/distributions.proto + +package distributionsv1alpha1 + +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 + +// Distribution configuration data. +type DistributionsParameters struct { + // The amount of staking token issued per block. + StakingIssuancePerBlock uint64 `protobuf:"varint,1,opt,name=staking_issuance_per_block,json=stakingIssuancePerBlock,proto3" json:"staking_issuance_per_block,omitempty"` +} + +func (m *DistributionsParameters) Reset() { *m = DistributionsParameters{} } +func (m *DistributionsParameters) String() string { return proto.CompactTextString(m) } +func (*DistributionsParameters) ProtoMessage() {} +func (*DistributionsParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_5006eea51ea29289, []int{0} +} +func (m *DistributionsParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DistributionsParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DistributionsParameters.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 *DistributionsParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_DistributionsParameters.Merge(m, src) +} +func (m *DistributionsParameters) XXX_Size() int { + return m.Size() +} +func (m *DistributionsParameters) XXX_DiscardUnknown() { + xxx_messageInfo_DistributionsParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_DistributionsParameters proto.InternalMessageInfo + +func (m *DistributionsParameters) GetStakingIssuancePerBlock() uint64 { + if m != nil { + return m.StakingIssuancePerBlock + } + return 0 +} + +// Genesis data for the distributions module. +type GenesisContent struct { + DistributionsParams *DistributionsParameters `protobuf:"bytes,1,opt,name=distributions_params,json=distributionsParams,proto3" json:"distributions_params,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_5006eea51ea29289, []int{1} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.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 *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetDistributionsParams() *DistributionsParameters { + if m != nil { + return m.DistributionsParams + } + return nil +} + +func init() { + proto.RegisterType((*DistributionsParameters)(nil), "penumbra.core.component.distributions.v1alpha1.DistributionsParameters") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.distributions.v1alpha1.GenesisContent") +} + +func init() { + proto.RegisterFile("penumbra/core/component/distributions/v1alpha1/distributions.proto", fileDescriptor_5006eea51ea29289) +} + +var fileDescriptor_5006eea51ea29289 = []byte{ + // 372 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x31, 0x4b, 0xf3, 0x40, + 0x18, 0xc7, 0x9b, 0xbc, 0xe5, 0x1d, 0x22, 0x38, 0x44, 0xa1, 0xe2, 0x10, 0xa4, 0x93, 0xd3, 0x1d, + 0x8d, 0x5b, 0xba, 0x25, 0x85, 0xe2, 0x20, 0x84, 0x0e, 0x1d, 0x24, 0x10, 0x2e, 0xe9, 0xd1, 0x1e, + 0x6d, 0xee, 0xc2, 0xdd, 0xa5, 0xa0, 0x9f, 0xc1, 0xc1, 0xcf, 0xe0, 0xe8, 0xe2, 0xd7, 0x10, 0xa7, + 0x8e, 0x8e, 0x92, 0x6e, 0x7e, 0x0a, 0xb9, 0x92, 0x8b, 0x1e, 0xe2, 0x90, 0x25, 0x84, 0xe7, 0x79, + 0x7e, 0xff, 0xe7, 0xc7, 0xdd, 0x39, 0x61, 0x89, 0x69, 0x55, 0x64, 0x1c, 0xc1, 0x9c, 0x71, 0x0c, + 0x73, 0x56, 0x94, 0x8c, 0x62, 0x2a, 0xe1, 0x82, 0x08, 0xc9, 0x49, 0x56, 0x49, 0xc2, 0xa8, 0x80, + 0xdb, 0x11, 0xda, 0x94, 0x2b, 0x34, 0x32, 0xcb, 0xa0, 0xe4, 0x4c, 0x32, 0x17, 0xe8, 0x0c, 0xa0, + 0x32, 0x40, 0x9b, 0x01, 0xcc, 0x61, 0x9d, 0x31, 0x9c, 0x3b, 0x83, 0xc9, 0xcf, 0x4e, 0x8c, 0x38, + 0x2a, 0xb0, 0xc4, 0x5c, 0xb8, 0x63, 0xe7, 0x5c, 0x48, 0xb4, 0x26, 0x74, 0x99, 0x12, 0x21, 0x2a, + 0x44, 0x73, 0x9c, 0x96, 0x98, 0xa7, 0xd9, 0x86, 0xe5, 0xeb, 0x33, 0xeb, 0xc2, 0xba, 0xec, 0xcf, + 0x06, 0xcd, 0xc4, 0x75, 0x33, 0x10, 0x63, 0x1e, 0xaa, 0xf6, 0xf0, 0xc1, 0x72, 0x8e, 0xa7, 0x98, + 0x62, 0x41, 0x44, 0xc4, 0xa8, 0xc4, 0x54, 0xba, 0xf7, 0xce, 0xa9, 0x21, 0x91, 0x96, 0x6a, 0x97, + 0x38, 0x24, 0x1d, 0xf9, 0xd3, 0x8e, 0xe6, 0xe0, 0x0f, 0xed, 0xd9, 0xc9, 0xe2, 0x57, 0x43, 0x84, + 0x2f, 0xff, 0x5e, 0x6b, 0xcf, 0xda, 0xd5, 0x9e, 0xf5, 0x51, 0x7b, 0xd6, 0xe3, 0xde, 0xeb, 0xed, + 0xf6, 0x5e, 0xef, 0x7d, 0xef, 0xf5, 0x1c, 0x3f, 0x67, 0x45, 0xc7, 0xdd, 0xa1, 0x6b, 0x2e, 0x57, + 0x27, 0x1f, 0x5b, 0xb7, 0xe5, 0x92, 0xc8, 0x55, 0x95, 0x29, 0x1c, 0xe6, 0x4c, 0x14, 0x4c, 0x40, + 0x8e, 0x37, 0xe8, 0x0e, 0x73, 0xb8, 0xf5, 0xdb, 0xdf, 0x7c, 0x85, 0x08, 0x15, 0xb0, 0xdb, 0x5d, + 0x8f, 0x8d, 0xb2, 0xae, 0x3e, 0xd9, 0xfd, 0x38, 0x8a, 0x26, 0xcf, 0x36, 0x88, 0xb5, 0x7f, 0xa4, + 0xfc, 0xa3, 0xd6, 0xdf, 0xf0, 0x04, 0xf3, 0x86, 0x7b, 0xfb, 0x06, 0x12, 0x05, 0x24, 0x2d, 0x90, + 0x18, 0x40, 0xa2, 0x81, 0xda, 0x0e, 0xba, 0x01, 0xc9, 0x34, 0x0e, 0x6f, 0xb0, 0x44, 0x0b, 0x24, + 0xd1, 0xa7, 0xed, 0x6b, 0x38, 0x08, 0x14, 0xad, 0xbe, 0x0d, 0x1e, 0x04, 0x06, 0x1f, 0x04, 0x3a, + 0x20, 0xfb, 0x7f, 0x78, 0xcf, 0x57, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x38, 0x4c, 0xa2, + 0x15, 0x03, 0x00, 0x00, +} + +func (m *DistributionsParameters) 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 *DistributionsParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DistributionsParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.StakingIssuancePerBlock != 0 { + i = encodeVarintDistributions(dAtA, i, uint64(m.StakingIssuancePerBlock)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DistributionsParams != nil { + { + size, err := m.DistributionsParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDistributions(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintDistributions(dAtA []byte, offset int, v uint64) int { + offset -= sovDistributions(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *DistributionsParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StakingIssuancePerBlock != 0 { + n += 1 + sovDistributions(uint64(m.StakingIssuancePerBlock)) + } + return n +} + +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DistributionsParams != nil { + l = m.DistributionsParams.Size() + n += 1 + l + sovDistributions(uint64(l)) + } + return n +} + +func sovDistributions(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozDistributions(x uint64) (n int) { + return sovDistributions(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *DistributionsParameters) 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 ErrIntOverflowDistributions + } + 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: DistributionsParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DistributionsParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StakingIssuancePerBlock", wireType) + } + m.StakingIssuancePerBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributions + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StakingIssuancePerBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDistributions(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDistributions + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent) 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 ErrIntOverflowDistributions + } + 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: GenesisContent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DistributionsParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributions + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDistributions + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDistributions + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DistributionsParams == nil { + m.DistributionsParams = &DistributionsParameters{} + } + if err := m.DistributionsParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDistributions(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDistributions + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipDistributions(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, ErrIntOverflowDistributions + } + 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, ErrIntOverflowDistributions + } + 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, ErrIntOverflowDistributions + } + 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, ErrInvalidLengthDistributions + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupDistributions + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthDistributions + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthDistributions = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDistributions = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupDistributions = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/component/fee/v1alpha1/fee.pb.go b/relayer/chains/penumbra/core/component/fee/v1alpha1/fee.pb.go new file mode 100644 index 000000000..6e6956a2a --- /dev/null +++ b/relayer/chains/penumbra/core/component/fee/v1alpha1/fee.pb.go @@ -0,0 +1,1039 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/fee/v1alpha1/fee.proto + +package feev1alpha1 + +import ( + fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" + 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 + +// Specifies fees paid by a transaction. +type Fee struct { + // The amount of the token used to pay fees. + Amount *v1alpha1.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` + // If present, the asset ID of the token used to pay fees. + // If absent, specifies the staking token implicitly. + AssetId *v1alpha11.AssetId `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` +} + +func (m *Fee) Reset() { *m = Fee{} } +func (m *Fee) String() string { return proto.CompactTextString(m) } +func (*Fee) ProtoMessage() {} +func (*Fee) Descriptor() ([]byte, []int) { + return fileDescriptor_03007f6a7f31c8af, []int{0} +} +func (m *Fee) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Fee) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Fee.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 *Fee) XXX_Merge(src proto.Message) { + xxx_messageInfo_Fee.Merge(m, src) +} +func (m *Fee) XXX_Size() int { + return m.Size() +} +func (m *Fee) XXX_DiscardUnknown() { + xxx_messageInfo_Fee.DiscardUnknown(m) +} + +var xxx_messageInfo_Fee proto.InternalMessageInfo + +func (m *Fee) GetAmount() *v1alpha1.Amount { + if m != nil { + return m.Amount + } + return nil +} + +func (m *Fee) GetAssetId() *v1alpha11.AssetId { + if m != nil { + return m.AssetId + } + return nil +} + +type GasPrices struct { + // The price per unit block space in terms of the staking token, with an implicit 1,000 denominator. + BlockSpacePrice uint64 `protobuf:"varint,1,opt,name=block_space_price,json=blockSpacePrice,proto3" json:"block_space_price,omitempty"` + // The price per unit compact block space in terms of the staking token, with an implicit 1,000 denominator. + CompactBlockSpacePrice uint64 `protobuf:"varint,2,opt,name=compact_block_space_price,json=compactBlockSpacePrice,proto3" json:"compact_block_space_price,omitempty"` + // The price per unit verification cost in terms of the staking token, with an implicit 1,000 denominator. + VerificationPrice uint64 `protobuf:"varint,3,opt,name=verification_price,json=verificationPrice,proto3" json:"verification_price,omitempty"` + // The price per unit execution cost in terms of the staking token, with an implicit 1,000 denominator. + ExecutionPrice uint64 `protobuf:"varint,4,opt,name=execution_price,json=executionPrice,proto3" json:"execution_price,omitempty"` +} + +func (m *GasPrices) Reset() { *m = GasPrices{} } +func (m *GasPrices) String() string { return proto.CompactTextString(m) } +func (*GasPrices) ProtoMessage() {} +func (*GasPrices) Descriptor() ([]byte, []int) { + return fileDescriptor_03007f6a7f31c8af, []int{1} +} +func (m *GasPrices) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GasPrices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GasPrices.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 *GasPrices) XXX_Merge(src proto.Message) { + xxx_messageInfo_GasPrices.Merge(m, src) +} +func (m *GasPrices) XXX_Size() int { + return m.Size() +} +func (m *GasPrices) XXX_DiscardUnknown() { + xxx_messageInfo_GasPrices.DiscardUnknown(m) +} + +var xxx_messageInfo_GasPrices proto.InternalMessageInfo + +func (m *GasPrices) GetBlockSpacePrice() uint64 { + if m != nil { + return m.BlockSpacePrice + } + return 0 +} + +func (m *GasPrices) GetCompactBlockSpacePrice() uint64 { + if m != nil { + return m.CompactBlockSpacePrice + } + return 0 +} + +func (m *GasPrices) GetVerificationPrice() uint64 { + if m != nil { + return m.VerificationPrice + } + return 0 +} + +func (m *GasPrices) GetExecutionPrice() uint64 { + if m != nil { + return m.ExecutionPrice + } + return 0 +} + +// Fee component configuration data. +type FeeParameters struct { +} + +func (m *FeeParameters) Reset() { *m = FeeParameters{} } +func (m *FeeParameters) String() string { return proto.CompactTextString(m) } +func (*FeeParameters) ProtoMessage() {} +func (*FeeParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_03007f6a7f31c8af, []int{2} +} +func (m *FeeParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FeeParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FeeParameters.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 *FeeParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_FeeParameters.Merge(m, src) +} +func (m *FeeParameters) XXX_Size() int { + return m.Size() +} +func (m *FeeParameters) XXX_DiscardUnknown() { + xxx_messageInfo_FeeParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_FeeParameters proto.InternalMessageInfo + +// Fee-specific genesis content. +type GenesisContent struct { + // The FeeParameters present at genesis. + FeeParams *FeeParameters `protobuf:"bytes,1,opt,name=fee_params,json=feeParams,proto3" json:"fee_params,omitempty"` + // The initial gas prices. + GasPrices *GasPrices `protobuf:"bytes,2,opt,name=gas_prices,json=gasPrices,proto3" json:"gas_prices,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_03007f6a7f31c8af, []int{3} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.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 *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetFeeParams() *FeeParameters { + if m != nil { + return m.FeeParams + } + return nil +} + +func (m *GenesisContent) GetGasPrices() *GasPrices { + if m != nil { + return m.GasPrices + } + return nil +} + +func init() { + proto.RegisterType((*Fee)(nil), "penumbra.core.component.fee.v1alpha1.Fee") + proto.RegisterType((*GasPrices)(nil), "penumbra.core.component.fee.v1alpha1.GasPrices") + proto.RegisterType((*FeeParameters)(nil), "penumbra.core.component.fee.v1alpha1.FeeParameters") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.fee.v1alpha1.GenesisContent") +} + +func init() { + proto.RegisterFile("penumbra/core/component/fee/v1alpha1/fee.proto", fileDescriptor_03007f6a7f31c8af) +} + +var fileDescriptor_03007f6a7f31c8af = []byte{ + // 521 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x4f, 0x8b, 0xd3, 0x40, + 0x18, 0x87, 0x9b, 0x6c, 0x59, 0xb7, 0x23, 0x6e, 0xd9, 0x1c, 0x64, 0xdd, 0x43, 0x90, 0x52, 0xb1, + 0x08, 0x4e, 0xdc, 0xdd, 0x93, 0xf1, 0xa2, 0x2d, 0xa4, 0x78, 0x50, 0x42, 0x04, 0x0f, 0x12, 0x08, + 0xd3, 0xe9, 0x9b, 0x36, 0xd8, 0xcc, 0x84, 0xcc, 0xa4, 0xe8, 0xd9, 0x2f, 0xe0, 0x67, 0xf0, 0xe8, + 0xd9, 0x0f, 0x21, 0x7b, 0xda, 0xa3, 0x37, 0xa5, 0xbd, 0xf9, 0x29, 0x64, 0x26, 0x7f, 0xba, 0x5d, + 0x2f, 0xb9, 0x94, 0xf7, 0x9d, 0x79, 0x9e, 0xb7, 0x3f, 0x26, 0x33, 0x08, 0x67, 0xc0, 0x8a, 0x74, + 0x96, 0x13, 0x87, 0xf2, 0x1c, 0x1c, 0xca, 0xd3, 0x8c, 0x33, 0x60, 0xd2, 0x89, 0x01, 0x9c, 0xf5, + 0x39, 0x59, 0x65, 0x4b, 0x72, 0xae, 0x1a, 0x9c, 0xe5, 0x5c, 0x72, 0x6b, 0x58, 0xf3, 0x58, 0xf1, + 0xb8, 0xe1, 0xb1, 0x42, 0x6a, 0xfe, 0x6c, 0xb4, 0x3f, 0x95, 0x08, 0x01, 0x72, 0x37, 0x4d, 0xb7, + 0xe5, 0xbc, 0xb3, 0xe1, 0x3e, 0xc9, 0x8a, 0x74, 0xc7, 0xb1, 0x22, 0x2d, 0xa9, 0xc1, 0x17, 0x03, + 0x1d, 0x78, 0x00, 0x96, 0x8b, 0x0e, 0x49, 0xca, 0x0b, 0x26, 0x4f, 0x8d, 0x87, 0xc6, 0xe8, 0xee, + 0xc5, 0x00, 0xef, 0xc7, 0x51, 0x46, 0xad, 0xe3, 0x57, 0x9a, 0x0c, 0x2a, 0xc3, 0x7a, 0x89, 0x8e, + 0xf4, 0x1f, 0x47, 0xc9, 0xfc, 0xd4, 0xd4, 0xf6, 0xa3, 0x5b, 0x76, 0x99, 0x6b, 0xe7, 0xab, 0xf6, + 0xf5, 0x3c, 0xb8, 0x43, 0xca, 0x62, 0x70, 0x65, 0xa0, 0xde, 0x94, 0x08, 0x3f, 0x4f, 0x28, 0x08, + 0xeb, 0x09, 0x3a, 0x99, 0xad, 0x38, 0xfd, 0x18, 0x89, 0x8c, 0x50, 0x88, 0x32, 0xb5, 0xaa, 0x63, + 0x75, 0x83, 0xbe, 0xde, 0x78, 0xa7, 0xd6, 0x35, 0x6c, 0x3d, 0x47, 0x0f, 0xd4, 0x49, 0x11, 0x2a, + 0xa3, 0xff, 0x1d, 0x53, 0x3b, 0xf7, 0x2b, 0x60, 0x7c, 0x4b, 0x7d, 0x8a, 0xac, 0x35, 0xe4, 0x49, + 0x9c, 0x50, 0x22, 0x13, 0xce, 0x2a, 0xe7, 0x40, 0x3b, 0x27, 0x37, 0x77, 0x4a, 0xfc, 0x31, 0xea, + 0xc3, 0x27, 0xa0, 0xc5, 0x0d, 0xb6, 0xab, 0xd9, 0xe3, 0x66, 0x59, 0x83, 0x83, 0x3e, 0xba, 0xe7, + 0x01, 0xf8, 0x24, 0x27, 0x29, 0x48, 0xc8, 0xc5, 0xe0, 0x87, 0x81, 0x8e, 0xa7, 0xc0, 0x40, 0x24, + 0x62, 0xc2, 0x99, 0x04, 0x26, 0xad, 0x00, 0xa1, 0x18, 0x20, 0xca, 0x14, 0x24, 0xaa, 0x23, 0xbf, + 0xc4, 0x6d, 0x6e, 0x00, 0xde, 0x9b, 0x1d, 0xf4, 0xe2, 0xaa, 0x15, 0xd6, 0x5b, 0x84, 0x16, 0x44, + 0x94, 0xd1, 0x44, 0xf5, 0x21, 0x9c, 0x76, 0x33, 0x9b, 0xb3, 0x0f, 0x7a, 0x8b, 0xba, 0x1c, 0xff, + 0x36, 0x7f, 0x6e, 0x6c, 0xe3, 0x7a, 0x63, 0x1b, 0x7f, 0x36, 0xb6, 0xf1, 0x75, 0x6b, 0x77, 0xae, + 0xb7, 0x76, 0xe7, 0xd7, 0xd6, 0xee, 0xa0, 0x11, 0xe5, 0x69, 0xab, 0xc9, 0xe3, 0x23, 0x15, 0x57, + 0xdd, 0x34, 0xdf, 0xf8, 0x10, 0x2e, 0x12, 0xb9, 0x2c, 0x66, 0x0a, 0x75, 0x28, 0x17, 0x29, 0x17, + 0x4e, 0x0e, 0x2b, 0xf2, 0x19, 0x72, 0x67, 0x7d, 0xd1, 0x94, 0x74, 0x49, 0x12, 0x26, 0x9c, 0x36, + 0xaf, 0xe7, 0x45, 0x0c, 0x50, 0xd7, 0xdf, 0xcc, 0xae, 0x3f, 0x99, 0x78, 0xdf, 0xcd, 0xa1, 0x5f, + 0xe7, 0x9a, 0xa8, 0x5c, 0x93, 0x26, 0x97, 0x07, 0x80, 0xdf, 0x57, 0xf4, 0xd5, 0x0e, 0x0b, 0x15, + 0x16, 0x36, 0x58, 0xe8, 0x01, 0x84, 0x35, 0xb6, 0x31, 0x9f, 0xb5, 0xc1, 0xc2, 0xa9, 0x3f, 0x7e, + 0x03, 0x92, 0xcc, 0x89, 0x24, 0x7f, 0xcd, 0x51, 0xad, 0xb8, 0xae, 0x72, 0xd4, 0x6f, 0x25, 0xb9, + 0xae, 0x07, 0xe0, 0xba, 0xb5, 0x36, 0x3b, 0xd4, 0x6f, 0xf0, 0xf2, 0x5f, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x97, 0x08, 0x0b, 0xac, 0x2b, 0x04, 0x00, 0x00, +} + +func (m *Fee) 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 *Fee) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Fee) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AssetId != nil { + { + size, err := m.AssetId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Amount != nil { + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GasPrices) 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 *GasPrices) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GasPrices) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ExecutionPrice != 0 { + i = encodeVarintFee(dAtA, i, uint64(m.ExecutionPrice)) + i-- + dAtA[i] = 0x20 + } + if m.VerificationPrice != 0 { + i = encodeVarintFee(dAtA, i, uint64(m.VerificationPrice)) + i-- + dAtA[i] = 0x18 + } + if m.CompactBlockSpacePrice != 0 { + i = encodeVarintFee(dAtA, i, uint64(m.CompactBlockSpacePrice)) + i-- + dAtA[i] = 0x10 + } + if m.BlockSpacePrice != 0 { + i = encodeVarintFee(dAtA, i, uint64(m.BlockSpacePrice)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *FeeParameters) 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 *FeeParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FeeParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.GasPrices != nil { + { + size, err := m.GasPrices.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.FeeParams != nil { + { + size, err := m.FeeParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintFee(dAtA []byte, offset int, v uint64) int { + offset -= sovFee(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Fee) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Amount != nil { + l = m.Amount.Size() + n += 1 + l + sovFee(uint64(l)) + } + if m.AssetId != nil { + l = m.AssetId.Size() + n += 1 + l + sovFee(uint64(l)) + } + return n +} + +func (m *GasPrices) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockSpacePrice != 0 { + n += 1 + sovFee(uint64(m.BlockSpacePrice)) + } + if m.CompactBlockSpacePrice != 0 { + n += 1 + sovFee(uint64(m.CompactBlockSpacePrice)) + } + if m.VerificationPrice != 0 { + n += 1 + sovFee(uint64(m.VerificationPrice)) + } + if m.ExecutionPrice != 0 { + n += 1 + sovFee(uint64(m.ExecutionPrice)) + } + return n +} + +func (m *FeeParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FeeParams != nil { + l = m.FeeParams.Size() + n += 1 + l + sovFee(uint64(l)) + } + if m.GasPrices != nil { + l = m.GasPrices.Size() + n += 1 + l + sovFee(uint64(l)) + } + return n +} + +func sovFee(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozFee(x uint64) (n int) { + return sovFee(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Fee) 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 ErrIntOverflowFee + } + 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: Fee: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Fee: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Amount == nil { + m.Amount = &v1alpha1.Amount{} + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AssetId == nil { + m.AssetId = &v1alpha11.AssetId{} + } + if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFee(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthFee + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GasPrices) 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 ErrIntOverflowFee + } + 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: GasPrices: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GasPrices: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockSpacePrice", wireType) + } + m.BlockSpacePrice = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockSpacePrice |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompactBlockSpacePrice", wireType) + } + m.CompactBlockSpacePrice = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CompactBlockSpacePrice |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VerificationPrice", wireType) + } + m.VerificationPrice = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VerificationPrice |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPrice", wireType) + } + m.ExecutionPrice = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ExecutionPrice |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFee(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthFee + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FeeParameters) 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 ErrIntOverflowFee + } + 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: FeeParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FeeParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipFee(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthFee + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent) 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 ErrIntOverflowFee + } + 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: GenesisContent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FeeParams == nil { + m.FeeParams = &FeeParameters{} + } + if err := m.FeeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasPrices", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasPrices == nil { + m.GasPrices = &GasPrices{} + } + if err := m.GasPrices.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFee(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthFee + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipFee(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, ErrIntOverflowFee + } + 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, ErrIntOverflowFee + } + 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, ErrIntOverflowFee + } + 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, ErrInvalidLengthFee + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupFee + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthFee + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthFee = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFee = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupFee = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/component/governance/v1alpha1/governance.pb.go b/relayer/chains/penumbra/core/component/governance/v1alpha1/governance.pb.go new file mode 100644 index 000000000..30ca2ad7d --- /dev/null +++ b/relayer/chains/penumbra/core/component/governance/v1alpha1/governance.pb.go @@ -0,0 +1,14715 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/governance/v1alpha1/governance.proto + +package governancev1alpha1 + +import ( + context "context" + fmt "fmt" + types "github.com/cosmos/cosmos-sdk/codec/types" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + v1alpha13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + v1alpha17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/chain/v1alpha1" + v1alpha18 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/community_pool/v1alpha1" + v1alpha111 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/distributions/v1alpha1" + v1alpha110 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1alpha1" + v1alpha19 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1alpha1" + v1alpha14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1alpha1" + v1alpha15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1alpha1" + v1alpha16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1alpha1" + v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_rdsa/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +// A vote. +type Vote_Vote int32 + +const ( + Vote_VOTE_UNSPECIFIED Vote_Vote = 0 + Vote_VOTE_ABSTAIN Vote_Vote = 1 + Vote_VOTE_YES Vote_Vote = 2 + Vote_VOTE_NO Vote_Vote = 3 +) + +var Vote_Vote_name = map[int32]string{ + 0: "VOTE_UNSPECIFIED", + 1: "VOTE_ABSTAIN", + 2: "VOTE_YES", + 3: "VOTE_NO", +} + +var Vote_Vote_value = map[string]int32{ + "VOTE_UNSPECIFIED": 0, + "VOTE_ABSTAIN": 1, + "VOTE_YES": 2, + "VOTE_NO": 3, +} + +func (x Vote_Vote) String() string { + return proto.EnumName(Vote_Vote_name, int32(x)) +} + +func (Vote_Vote) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{14, 0} +} + +// A Penumbra ZK delegator vote proof. +type ZKDelegatorVoteProof struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *ZKDelegatorVoteProof) Reset() { *m = ZKDelegatorVoteProof{} } +func (m *ZKDelegatorVoteProof) String() string { return proto.CompactTextString(m) } +func (*ZKDelegatorVoteProof) ProtoMessage() {} +func (*ZKDelegatorVoteProof) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{0} +} +func (m *ZKDelegatorVoteProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZKDelegatorVoteProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZKDelegatorVoteProof.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 *ZKDelegatorVoteProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZKDelegatorVoteProof.Merge(m, src) +} +func (m *ZKDelegatorVoteProof) XXX_Size() int { + return m.Size() +} +func (m *ZKDelegatorVoteProof) XXX_DiscardUnknown() { + xxx_messageInfo_ZKDelegatorVoteProof.DiscardUnknown(m) +} + +var xxx_messageInfo_ZKDelegatorVoteProof proto.InternalMessageInfo + +func (m *ZKDelegatorVoteProof) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +type ProposalSubmit struct { + // The proposal to be submitted. + Proposal *Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + // The amount of the proposal deposit. + DepositAmount *v1alpha1.Amount `protobuf:"bytes,3,opt,name=deposit_amount,json=depositAmount,proto3" json:"deposit_amount,omitempty"` +} + +func (m *ProposalSubmit) Reset() { *m = ProposalSubmit{} } +func (m *ProposalSubmit) String() string { return proto.CompactTextString(m) } +func (*ProposalSubmit) ProtoMessage() {} +func (*ProposalSubmit) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{1} +} +func (m *ProposalSubmit) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalSubmit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalSubmit.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 *ProposalSubmit) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalSubmit.Merge(m, src) +} +func (m *ProposalSubmit) XXX_Size() int { + return m.Size() +} +func (m *ProposalSubmit) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalSubmit.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalSubmit proto.InternalMessageInfo + +func (m *ProposalSubmit) GetProposal() *Proposal { + if m != nil { + return m.Proposal + } + return nil +} + +func (m *ProposalSubmit) GetDepositAmount() *v1alpha1.Amount { + if m != nil { + return m.DepositAmount + } + return nil +} + +type ProposalWithdraw struct { + // The proposal to be withdrawn. + Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + // The reason for the proposal being withdrawn. + Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` +} + +func (m *ProposalWithdraw) Reset() { *m = ProposalWithdraw{} } +func (m *ProposalWithdraw) String() string { return proto.CompactTextString(m) } +func (*ProposalWithdraw) ProtoMessage() {} +func (*ProposalWithdraw) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{2} +} +func (m *ProposalWithdraw) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalWithdraw) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalWithdraw.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 *ProposalWithdraw) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalWithdraw.Merge(m, src) +} +func (m *ProposalWithdraw) XXX_Size() int { + return m.Size() +} +func (m *ProposalWithdraw) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalWithdraw.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalWithdraw proto.InternalMessageInfo + +func (m *ProposalWithdraw) GetProposal() uint64 { + if m != nil { + return m.Proposal + } + return 0 +} + +func (m *ProposalWithdraw) GetReason() string { + if m != nil { + return m.Reason + } + return "" +} + +type ProposalDepositClaim struct { + // The proposal to claim the deposit for. + Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + // The expected deposit amount. + DepositAmount *v1alpha1.Amount `protobuf:"bytes,2,opt,name=deposit_amount,json=depositAmount,proto3" json:"deposit_amount,omitempty"` + // The outcome of the proposal. + Outcome *ProposalOutcome `protobuf:"bytes,3,opt,name=outcome,proto3" json:"outcome,omitempty"` +} + +func (m *ProposalDepositClaim) Reset() { *m = ProposalDepositClaim{} } +func (m *ProposalDepositClaim) String() string { return proto.CompactTextString(m) } +func (*ProposalDepositClaim) ProtoMessage() {} +func (*ProposalDepositClaim) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{3} +} +func (m *ProposalDepositClaim) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalDepositClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalDepositClaim.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 *ProposalDepositClaim) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalDepositClaim.Merge(m, src) +} +func (m *ProposalDepositClaim) XXX_Size() int { + return m.Size() +} +func (m *ProposalDepositClaim) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalDepositClaim.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalDepositClaim proto.InternalMessageInfo + +func (m *ProposalDepositClaim) GetProposal() uint64 { + if m != nil { + return m.Proposal + } + return 0 +} + +func (m *ProposalDepositClaim) GetDepositAmount() *v1alpha1.Amount { + if m != nil { + return m.DepositAmount + } + return nil +} + +func (m *ProposalDepositClaim) GetOutcome() *ProposalOutcome { + if m != nil { + return m.Outcome + } + return nil +} + +type ValidatorVote struct { + // The effecting data for the vote. + Body *ValidatorVoteBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` + // The vote authorization signature is authorizing data. + AuthSig *v1alpha11.SpendAuthSignature `protobuf:"bytes,2,opt,name=auth_sig,json=authSig,proto3" json:"auth_sig,omitempty"` +} + +func (m *ValidatorVote) Reset() { *m = ValidatorVote{} } +func (m *ValidatorVote) String() string { return proto.CompactTextString(m) } +func (*ValidatorVote) ProtoMessage() {} +func (*ValidatorVote) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{4} +} +func (m *ValidatorVote) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorVote.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 *ValidatorVote) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorVote.Merge(m, src) +} +func (m *ValidatorVote) XXX_Size() int { + return m.Size() +} +func (m *ValidatorVote) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorVote.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorVote proto.InternalMessageInfo + +func (m *ValidatorVote) GetBody() *ValidatorVoteBody { + if m != nil { + return m.Body + } + return nil +} + +func (m *ValidatorVote) GetAuthSig() *v1alpha11.SpendAuthSignature { + if m != nil { + return m.AuthSig + } + return nil +} + +type ValidatorVoteReason struct { + Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` +} + +func (m *ValidatorVoteReason) Reset() { *m = ValidatorVoteReason{} } +func (m *ValidatorVoteReason) String() string { return proto.CompactTextString(m) } +func (*ValidatorVoteReason) ProtoMessage() {} +func (*ValidatorVoteReason) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{5} +} +func (m *ValidatorVoteReason) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorVoteReason) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorVoteReason.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 *ValidatorVoteReason) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorVoteReason.Merge(m, src) +} +func (m *ValidatorVoteReason) XXX_Size() int { + return m.Size() +} +func (m *ValidatorVoteReason) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorVoteReason.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorVoteReason proto.InternalMessageInfo + +func (m *ValidatorVoteReason) GetReason() string { + if m != nil { + return m.Reason + } + return "" +} + +type ValidatorVoteBody struct { + // The proposal being voted on. + Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + // The vote. + Vote *Vote `protobuf:"bytes,2,opt,name=vote,proto3" json:"vote,omitempty"` + // The validator identity. + IdentityKey *v1alpha12.IdentityKey `protobuf:"bytes,3,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` + // The validator governance key. + GovernanceKey *v1alpha12.GovernanceKey `protobuf:"bytes,4,opt,name=governance_key,json=governanceKey,proto3" json:"governance_key,omitempty"` + // A justification of the vote. + Reason *ValidatorVoteReason `protobuf:"bytes,5,opt,name=reason,proto3" json:"reason,omitempty"` +} + +func (m *ValidatorVoteBody) Reset() { *m = ValidatorVoteBody{} } +func (m *ValidatorVoteBody) String() string { return proto.CompactTextString(m) } +func (*ValidatorVoteBody) ProtoMessage() {} +func (*ValidatorVoteBody) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{6} +} +func (m *ValidatorVoteBody) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorVoteBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorVoteBody.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 *ValidatorVoteBody) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorVoteBody.Merge(m, src) +} +func (m *ValidatorVoteBody) XXX_Size() int { + return m.Size() +} +func (m *ValidatorVoteBody) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorVoteBody.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorVoteBody proto.InternalMessageInfo + +func (m *ValidatorVoteBody) GetProposal() uint64 { + if m != nil { + return m.Proposal + } + return 0 +} + +func (m *ValidatorVoteBody) GetVote() *Vote { + if m != nil { + return m.Vote + } + return nil +} + +func (m *ValidatorVoteBody) GetIdentityKey() *v1alpha12.IdentityKey { + if m != nil { + return m.IdentityKey + } + return nil +} + +func (m *ValidatorVoteBody) GetGovernanceKey() *v1alpha12.GovernanceKey { + if m != nil { + return m.GovernanceKey + } + return nil +} + +func (m *ValidatorVoteBody) GetReason() *ValidatorVoteReason { + if m != nil { + return m.Reason + } + return nil +} + +type DelegatorVote struct { + // The effecting data for the vote. + Body *DelegatorVoteBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` + // The vote authorization signature is authorizing data. + AuthSig *v1alpha11.SpendAuthSignature `protobuf:"bytes,2,opt,name=auth_sig,json=authSig,proto3" json:"auth_sig,omitempty"` + // The vote proof is authorizing data. + Proof *ZKDelegatorVoteProof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"` +} + +func (m *DelegatorVote) Reset() { *m = DelegatorVote{} } +func (m *DelegatorVote) String() string { return proto.CompactTextString(m) } +func (*DelegatorVote) ProtoMessage() {} +func (*DelegatorVote) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{7} +} +func (m *DelegatorVote) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DelegatorVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DelegatorVote.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 *DelegatorVote) XXX_Merge(src proto.Message) { + xxx_messageInfo_DelegatorVote.Merge(m, src) +} +func (m *DelegatorVote) XXX_Size() int { + return m.Size() +} +func (m *DelegatorVote) XXX_DiscardUnknown() { + xxx_messageInfo_DelegatorVote.DiscardUnknown(m) +} + +var xxx_messageInfo_DelegatorVote proto.InternalMessageInfo + +func (m *DelegatorVote) GetBody() *DelegatorVoteBody { + if m != nil { + return m.Body + } + return nil +} + +func (m *DelegatorVote) GetAuthSig() *v1alpha11.SpendAuthSignature { + if m != nil { + return m.AuthSig + } + return nil +} + +func (m *DelegatorVote) GetProof() *ZKDelegatorVoteProof { + if m != nil { + return m.Proof + } + return nil +} + +type DelegatorVoteBody struct { + // The proposal being voted on. + Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + // The start position of the proposal in the TCT. + StartPosition uint64 `protobuf:"varint,2,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"` + // The vote. + Vote *Vote `protobuf:"bytes,3,opt,name=vote,proto3" json:"vote,omitempty"` + // The value of the delegation note. + Value *v1alpha13.Value `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"` + // The amount of the delegation note, in unbonded penumbra. + UnbondedAmount *v1alpha1.Amount `protobuf:"bytes,5,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"` + // The nullifier of the input note. + Nullifier *v1alpha14.Nullifier `protobuf:"bytes,6,opt,name=nullifier,proto3" json:"nullifier,omitempty"` + // The randomized validating key for the spend authorization signature. + Rk *v1alpha11.SpendVerificationKey `protobuf:"bytes,7,opt,name=rk,proto3" json:"rk,omitempty"` +} + +func (m *DelegatorVoteBody) Reset() { *m = DelegatorVoteBody{} } +func (m *DelegatorVoteBody) String() string { return proto.CompactTextString(m) } +func (*DelegatorVoteBody) ProtoMessage() {} +func (*DelegatorVoteBody) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{8} +} +func (m *DelegatorVoteBody) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DelegatorVoteBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DelegatorVoteBody.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 *DelegatorVoteBody) XXX_Merge(src proto.Message) { + xxx_messageInfo_DelegatorVoteBody.Merge(m, src) +} +func (m *DelegatorVoteBody) XXX_Size() int { + return m.Size() +} +func (m *DelegatorVoteBody) XXX_DiscardUnknown() { + xxx_messageInfo_DelegatorVoteBody.DiscardUnknown(m) +} + +var xxx_messageInfo_DelegatorVoteBody proto.InternalMessageInfo + +func (m *DelegatorVoteBody) GetProposal() uint64 { + if m != nil { + return m.Proposal + } + return 0 +} + +func (m *DelegatorVoteBody) GetStartPosition() uint64 { + if m != nil { + return m.StartPosition + } + return 0 +} + +func (m *DelegatorVoteBody) GetVote() *Vote { + if m != nil { + return m.Vote + } + return nil +} + +func (m *DelegatorVoteBody) GetValue() *v1alpha13.Value { + if m != nil { + return m.Value + } + return nil +} + +func (m *DelegatorVoteBody) GetUnbondedAmount() *v1alpha1.Amount { + if m != nil { + return m.UnbondedAmount + } + return nil +} + +func (m *DelegatorVoteBody) GetNullifier() *v1alpha14.Nullifier { + if m != nil { + return m.Nullifier + } + return nil +} + +func (m *DelegatorVoteBody) GetRk() *v1alpha11.SpendVerificationKey { + if m != nil { + return m.Rk + } + return nil +} + +type DelegatorVoteView struct { + // Types that are valid to be assigned to DelegatorVote: + // *DelegatorVoteView_Visible_ + // *DelegatorVoteView_Opaque_ + DelegatorVote isDelegatorVoteView_DelegatorVote `protobuf_oneof:"delegator_vote"` +} + +func (m *DelegatorVoteView) Reset() { *m = DelegatorVoteView{} } +func (m *DelegatorVoteView) String() string { return proto.CompactTextString(m) } +func (*DelegatorVoteView) ProtoMessage() {} +func (*DelegatorVoteView) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{9} +} +func (m *DelegatorVoteView) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DelegatorVoteView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DelegatorVoteView.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 *DelegatorVoteView) XXX_Merge(src proto.Message) { + xxx_messageInfo_DelegatorVoteView.Merge(m, src) +} +func (m *DelegatorVoteView) XXX_Size() int { + return m.Size() +} +func (m *DelegatorVoteView) XXX_DiscardUnknown() { + xxx_messageInfo_DelegatorVoteView.DiscardUnknown(m) +} + +var xxx_messageInfo_DelegatorVoteView proto.InternalMessageInfo + +type isDelegatorVoteView_DelegatorVote interface { + isDelegatorVoteView_DelegatorVote() + MarshalTo([]byte) (int, error) + Size() int +} + +type DelegatorVoteView_Visible_ struct { + Visible *DelegatorVoteView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` +} +type DelegatorVoteView_Opaque_ struct { + Opaque *DelegatorVoteView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +} + +func (*DelegatorVoteView_Visible_) isDelegatorVoteView_DelegatorVote() {} +func (*DelegatorVoteView_Opaque_) isDelegatorVoteView_DelegatorVote() {} + +func (m *DelegatorVoteView) GetDelegatorVote() isDelegatorVoteView_DelegatorVote { + if m != nil { + return m.DelegatorVote + } + return nil +} + +func (m *DelegatorVoteView) GetVisible() *DelegatorVoteView_Visible { + if x, ok := m.GetDelegatorVote().(*DelegatorVoteView_Visible_); ok { + return x.Visible + } + return nil +} + +func (m *DelegatorVoteView) GetOpaque() *DelegatorVoteView_Opaque { + if x, ok := m.GetDelegatorVote().(*DelegatorVoteView_Opaque_); ok { + return x.Opaque + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*DelegatorVoteView) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*DelegatorVoteView_Visible_)(nil), + (*DelegatorVoteView_Opaque_)(nil), + } +} + +type DelegatorVoteView_Visible struct { + DelegatorVote *DelegatorVote `protobuf:"bytes,1,opt,name=delegator_vote,json=delegatorVote,proto3" json:"delegator_vote,omitempty"` + Note *v1alpha15.NoteView `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` +} + +func (m *DelegatorVoteView_Visible) Reset() { *m = DelegatorVoteView_Visible{} } +func (m *DelegatorVoteView_Visible) String() string { return proto.CompactTextString(m) } +func (*DelegatorVoteView_Visible) ProtoMessage() {} +func (*DelegatorVoteView_Visible) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{9, 0} +} +func (m *DelegatorVoteView_Visible) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DelegatorVoteView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DelegatorVoteView_Visible.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 *DelegatorVoteView_Visible) XXX_Merge(src proto.Message) { + xxx_messageInfo_DelegatorVoteView_Visible.Merge(m, src) +} +func (m *DelegatorVoteView_Visible) XXX_Size() int { + return m.Size() +} +func (m *DelegatorVoteView_Visible) XXX_DiscardUnknown() { + xxx_messageInfo_DelegatorVoteView_Visible.DiscardUnknown(m) +} + +var xxx_messageInfo_DelegatorVoteView_Visible proto.InternalMessageInfo + +func (m *DelegatorVoteView_Visible) GetDelegatorVote() *DelegatorVote { + if m != nil { + return m.DelegatorVote + } + return nil +} + +func (m *DelegatorVoteView_Visible) GetNote() *v1alpha15.NoteView { + if m != nil { + return m.Note + } + return nil +} + +type DelegatorVoteView_Opaque struct { + DelegatorVote *DelegatorVote `protobuf:"bytes,1,opt,name=delegator_vote,json=delegatorVote,proto3" json:"delegator_vote,omitempty"` +} + +func (m *DelegatorVoteView_Opaque) Reset() { *m = DelegatorVoteView_Opaque{} } +func (m *DelegatorVoteView_Opaque) String() string { return proto.CompactTextString(m) } +func (*DelegatorVoteView_Opaque) ProtoMessage() {} +func (*DelegatorVoteView_Opaque) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{9, 1} +} +func (m *DelegatorVoteView_Opaque) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DelegatorVoteView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DelegatorVoteView_Opaque.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 *DelegatorVoteView_Opaque) XXX_Merge(src proto.Message) { + xxx_messageInfo_DelegatorVoteView_Opaque.Merge(m, src) +} +func (m *DelegatorVoteView_Opaque) XXX_Size() int { + return m.Size() +} +func (m *DelegatorVoteView_Opaque) XXX_DiscardUnknown() { + xxx_messageInfo_DelegatorVoteView_Opaque.DiscardUnknown(m) +} + +var xxx_messageInfo_DelegatorVoteView_Opaque proto.InternalMessageInfo + +func (m *DelegatorVoteView_Opaque) GetDelegatorVote() *DelegatorVote { + if m != nil { + return m.DelegatorVote + } + return nil +} + +type DelegatorVotePlan struct { + // The proposal to vote on. + Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + // The start position of the proposal in the TCT. + StartPosition uint64 `protobuf:"varint,2,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"` + // The vote to cast. + Vote *Vote `protobuf:"bytes,3,opt,name=vote,proto3" json:"vote,omitempty"` + // The delegation note to prove that we can vote. + StakedNote *v1alpha15.Note `protobuf:"bytes,4,opt,name=staked_note,json=stakedNote,proto3" json:"staked_note,omitempty"` + // The position of that delegation note. + StakedNotePosition uint64 `protobuf:"varint,5,opt,name=staked_note_position,json=stakedNotePosition,proto3" json:"staked_note_position,omitempty"` + // The unbonded amount equivalent to the delegation note. + UnbondedAmount *v1alpha1.Amount `protobuf:"bytes,6,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"` + // The randomizer to use for the proof of spend capability. + Randomizer []byte `protobuf:"bytes,7,opt,name=randomizer,proto3" json:"randomizer,omitempty"` + // The first blinding factor to use for the ZK delegator vote proof. + ProofBlindingR []byte `protobuf:"bytes,8,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` + // The second blinding factor to use for the ZK delegator vote proof. + ProofBlindingS []byte `protobuf:"bytes,9,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` +} + +func (m *DelegatorVotePlan) Reset() { *m = DelegatorVotePlan{} } +func (m *DelegatorVotePlan) String() string { return proto.CompactTextString(m) } +func (*DelegatorVotePlan) ProtoMessage() {} +func (*DelegatorVotePlan) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{10} +} +func (m *DelegatorVotePlan) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DelegatorVotePlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DelegatorVotePlan.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 *DelegatorVotePlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_DelegatorVotePlan.Merge(m, src) +} +func (m *DelegatorVotePlan) XXX_Size() int { + return m.Size() +} +func (m *DelegatorVotePlan) XXX_DiscardUnknown() { + xxx_messageInfo_DelegatorVotePlan.DiscardUnknown(m) +} + +var xxx_messageInfo_DelegatorVotePlan proto.InternalMessageInfo + +func (m *DelegatorVotePlan) GetProposal() uint64 { + if m != nil { + return m.Proposal + } + return 0 +} + +func (m *DelegatorVotePlan) GetStartPosition() uint64 { + if m != nil { + return m.StartPosition + } + return 0 +} + +func (m *DelegatorVotePlan) GetVote() *Vote { + if m != nil { + return m.Vote + } + return nil +} + +func (m *DelegatorVotePlan) GetStakedNote() *v1alpha15.Note { + if m != nil { + return m.StakedNote + } + return nil +} + +func (m *DelegatorVotePlan) GetStakedNotePosition() uint64 { + if m != nil { + return m.StakedNotePosition + } + return 0 +} + +func (m *DelegatorVotePlan) GetUnbondedAmount() *v1alpha1.Amount { + if m != nil { + return m.UnbondedAmount + } + return nil +} + +func (m *DelegatorVotePlan) GetRandomizer() []byte { + if m != nil { + return m.Randomizer + } + return nil +} + +func (m *DelegatorVotePlan) GetProofBlindingR() []byte { + if m != nil { + return m.ProofBlindingR + } + return nil +} + +func (m *DelegatorVotePlan) GetProofBlindingS() []byte { + if m != nil { + return m.ProofBlindingS + } + return nil +} + +type CommunityPoolDeposit struct { + // The value to deposit into the Community Pool. + Value *v1alpha13.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *CommunityPoolDeposit) Reset() { *m = CommunityPoolDeposit{} } +func (m *CommunityPoolDeposit) String() string { return proto.CompactTextString(m) } +func (*CommunityPoolDeposit) ProtoMessage() {} +func (*CommunityPoolDeposit) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{11} +} +func (m *CommunityPoolDeposit) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommunityPoolDeposit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommunityPoolDeposit.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 *CommunityPoolDeposit) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommunityPoolDeposit.Merge(m, src) +} +func (m *CommunityPoolDeposit) XXX_Size() int { + return m.Size() +} +func (m *CommunityPoolDeposit) XXX_DiscardUnknown() { + xxx_messageInfo_CommunityPoolDeposit.DiscardUnknown(m) +} + +var xxx_messageInfo_CommunityPoolDeposit proto.InternalMessageInfo + +func (m *CommunityPoolDeposit) GetValue() *v1alpha13.Value { + if m != nil { + return m.Value + } + return nil +} + +type CommunityPoolSpend struct { + // The value to spend from the Community Pool. + Value *v1alpha13.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *CommunityPoolSpend) Reset() { *m = CommunityPoolSpend{} } +func (m *CommunityPoolSpend) String() string { return proto.CompactTextString(m) } +func (*CommunityPoolSpend) ProtoMessage() {} +func (*CommunityPoolSpend) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{12} +} +func (m *CommunityPoolSpend) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommunityPoolSpend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommunityPoolSpend.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 *CommunityPoolSpend) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommunityPoolSpend.Merge(m, src) +} +func (m *CommunityPoolSpend) XXX_Size() int { + return m.Size() +} +func (m *CommunityPoolSpend) XXX_DiscardUnknown() { + xxx_messageInfo_CommunityPoolSpend.DiscardUnknown(m) +} + +var xxx_messageInfo_CommunityPoolSpend proto.InternalMessageInfo + +func (m *CommunityPoolSpend) GetValue() *v1alpha13.Value { + if m != nil { + return m.Value + } + return nil +} + +type CommunityPoolOutput struct { + // The value to output from the Community Pool. + Value *v1alpha13.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + // The address to send the output to. + Address *v1alpha12.Address `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *CommunityPoolOutput) Reset() { *m = CommunityPoolOutput{} } +func (m *CommunityPoolOutput) String() string { return proto.CompactTextString(m) } +func (*CommunityPoolOutput) ProtoMessage() {} +func (*CommunityPoolOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{13} +} +func (m *CommunityPoolOutput) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommunityPoolOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommunityPoolOutput.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 *CommunityPoolOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommunityPoolOutput.Merge(m, src) +} +func (m *CommunityPoolOutput) XXX_Size() int { + return m.Size() +} +func (m *CommunityPoolOutput) XXX_DiscardUnknown() { + xxx_messageInfo_CommunityPoolOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_CommunityPoolOutput proto.InternalMessageInfo + +func (m *CommunityPoolOutput) GetValue() *v1alpha13.Value { + if m != nil { + return m.Value + } + return nil +} + +func (m *CommunityPoolOutput) GetAddress() *v1alpha12.Address { + if m != nil { + return m.Address + } + return nil +} + +// A vote on a proposal. +type Vote struct { + // The vote. + Vote Vote_Vote `protobuf:"varint,1,opt,name=vote,proto3,enum=penumbra.core.component.governance.v1alpha1.Vote_Vote" json:"vote,omitempty"` +} + +func (m *Vote) Reset() { *m = Vote{} } +func (m *Vote) String() string { return proto.CompactTextString(m) } +func (*Vote) ProtoMessage() {} +func (*Vote) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{14} +} +func (m *Vote) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Vote.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 *Vote) XXX_Merge(src proto.Message) { + xxx_messageInfo_Vote.Merge(m, src) +} +func (m *Vote) XXX_Size() int { + return m.Size() +} +func (m *Vote) XXX_DiscardUnknown() { + xxx_messageInfo_Vote.DiscardUnknown(m) +} + +var xxx_messageInfo_Vote proto.InternalMessageInfo + +func (m *Vote) GetVote() Vote_Vote { + if m != nil { + return m.Vote + } + return Vote_VOTE_UNSPECIFIED +} + +// The current state of a proposal. +type ProposalState struct { + // The state of the proposal. + // + // Types that are valid to be assigned to State: + // *ProposalState_Voting_ + // *ProposalState_Withdrawn_ + // *ProposalState_Finished_ + // *ProposalState_Claimed_ + State isProposalState_State `protobuf_oneof:"state"` +} + +func (m *ProposalState) Reset() { *m = ProposalState{} } +func (m *ProposalState) String() string { return proto.CompactTextString(m) } +func (*ProposalState) ProtoMessage() {} +func (*ProposalState) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{15} +} +func (m *ProposalState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalState.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 *ProposalState) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalState.Merge(m, src) +} +func (m *ProposalState) XXX_Size() int { + return m.Size() +} +func (m *ProposalState) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalState.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalState proto.InternalMessageInfo + +type isProposalState_State interface { + isProposalState_State() + MarshalTo([]byte) (int, error) + Size() int +} + +type ProposalState_Voting_ struct { + Voting *ProposalState_Voting `protobuf:"bytes,2,opt,name=voting,proto3,oneof" json:"voting,omitempty"` +} +type ProposalState_Withdrawn_ struct { + Withdrawn *ProposalState_Withdrawn `protobuf:"bytes,3,opt,name=withdrawn,proto3,oneof" json:"withdrawn,omitempty"` +} +type ProposalState_Finished_ struct { + Finished *ProposalState_Finished `protobuf:"bytes,4,opt,name=finished,proto3,oneof" json:"finished,omitempty"` +} +type ProposalState_Claimed_ struct { + Claimed *ProposalState_Claimed `protobuf:"bytes,5,opt,name=claimed,proto3,oneof" json:"claimed,omitempty"` +} + +func (*ProposalState_Voting_) isProposalState_State() {} +func (*ProposalState_Withdrawn_) isProposalState_State() {} +func (*ProposalState_Finished_) isProposalState_State() {} +func (*ProposalState_Claimed_) isProposalState_State() {} + +func (m *ProposalState) GetState() isProposalState_State { + if m != nil { + return m.State + } + return nil +} + +func (m *ProposalState) GetVoting() *ProposalState_Voting { + if x, ok := m.GetState().(*ProposalState_Voting_); ok { + return x.Voting + } + return nil +} + +func (m *ProposalState) GetWithdrawn() *ProposalState_Withdrawn { + if x, ok := m.GetState().(*ProposalState_Withdrawn_); ok { + return x.Withdrawn + } + return nil +} + +func (m *ProposalState) GetFinished() *ProposalState_Finished { + if x, ok := m.GetState().(*ProposalState_Finished_); ok { + return x.Finished + } + return nil +} + +func (m *ProposalState) GetClaimed() *ProposalState_Claimed { + if x, ok := m.GetState().(*ProposalState_Claimed_); ok { + return x.Claimed + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ProposalState) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ProposalState_Voting_)(nil), + (*ProposalState_Withdrawn_)(nil), + (*ProposalState_Finished_)(nil), + (*ProposalState_Claimed_)(nil), + } +} + +// Voting is in progress and the proposal has not yet concluded voting or been withdrawn. +type ProposalState_Voting struct { +} + +func (m *ProposalState_Voting) Reset() { *m = ProposalState_Voting{} } +func (m *ProposalState_Voting) String() string { return proto.CompactTextString(m) } +func (*ProposalState_Voting) ProtoMessage() {} +func (*ProposalState_Voting) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{15, 0} +} +func (m *ProposalState_Voting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalState_Voting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalState_Voting.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 *ProposalState_Voting) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalState_Voting.Merge(m, src) +} +func (m *ProposalState_Voting) XXX_Size() int { + return m.Size() +} +func (m *ProposalState_Voting) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalState_Voting.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalState_Voting proto.InternalMessageInfo + +// The proposal has been withdrawn but the voting period is not yet concluded. +type ProposalState_Withdrawn struct { + // The reason for the withdrawal. + Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` +} + +func (m *ProposalState_Withdrawn) Reset() { *m = ProposalState_Withdrawn{} } +func (m *ProposalState_Withdrawn) String() string { return proto.CompactTextString(m) } +func (*ProposalState_Withdrawn) ProtoMessage() {} +func (*ProposalState_Withdrawn) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{15, 1} +} +func (m *ProposalState_Withdrawn) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalState_Withdrawn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalState_Withdrawn.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 *ProposalState_Withdrawn) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalState_Withdrawn.Merge(m, src) +} +func (m *ProposalState_Withdrawn) XXX_Size() int { + return m.Size() +} +func (m *ProposalState_Withdrawn) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalState_Withdrawn.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalState_Withdrawn proto.InternalMessageInfo + +func (m *ProposalState_Withdrawn) GetReason() string { + if m != nil { + return m.Reason + } + return "" +} + +// The voting period has ended, and the proposal has been assigned an outcome. +type ProposalState_Finished struct { + Outcome *ProposalOutcome `protobuf:"bytes,1,opt,name=outcome,proto3" json:"outcome,omitempty"` +} + +func (m *ProposalState_Finished) Reset() { *m = ProposalState_Finished{} } +func (m *ProposalState_Finished) String() string { return proto.CompactTextString(m) } +func (*ProposalState_Finished) ProtoMessage() {} +func (*ProposalState_Finished) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{15, 2} +} +func (m *ProposalState_Finished) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalState_Finished) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalState_Finished.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 *ProposalState_Finished) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalState_Finished.Merge(m, src) +} +func (m *ProposalState_Finished) XXX_Size() int { + return m.Size() +} +func (m *ProposalState_Finished) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalState_Finished.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalState_Finished proto.InternalMessageInfo + +func (m *ProposalState_Finished) GetOutcome() *ProposalOutcome { + if m != nil { + return m.Outcome + } + return nil +} + +// The voting period has ended, and the original proposer has claimed their deposit. +type ProposalState_Claimed struct { + Outcome *ProposalOutcome `protobuf:"bytes,1,opt,name=outcome,proto3" json:"outcome,omitempty"` +} + +func (m *ProposalState_Claimed) Reset() { *m = ProposalState_Claimed{} } +func (m *ProposalState_Claimed) String() string { return proto.CompactTextString(m) } +func (*ProposalState_Claimed) ProtoMessage() {} +func (*ProposalState_Claimed) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{15, 3} +} +func (m *ProposalState_Claimed) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalState_Claimed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalState_Claimed.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 *ProposalState_Claimed) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalState_Claimed.Merge(m, src) +} +func (m *ProposalState_Claimed) XXX_Size() int { + return m.Size() +} +func (m *ProposalState_Claimed) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalState_Claimed.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalState_Claimed proto.InternalMessageInfo + +func (m *ProposalState_Claimed) GetOutcome() *ProposalOutcome { + if m != nil { + return m.Outcome + } + return nil +} + +// The outcome of a concluded proposal. +type ProposalOutcome struct { + // Types that are valid to be assigned to Outcome: + // *ProposalOutcome_Passed_ + // *ProposalOutcome_Failed_ + // *ProposalOutcome_Slashed_ + Outcome isProposalOutcome_Outcome `protobuf_oneof:"outcome"` +} + +func (m *ProposalOutcome) Reset() { *m = ProposalOutcome{} } +func (m *ProposalOutcome) String() string { return proto.CompactTextString(m) } +func (*ProposalOutcome) ProtoMessage() {} +func (*ProposalOutcome) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{16} +} +func (m *ProposalOutcome) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalOutcome) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalOutcome.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 *ProposalOutcome) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalOutcome.Merge(m, src) +} +func (m *ProposalOutcome) XXX_Size() int { + return m.Size() +} +func (m *ProposalOutcome) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalOutcome.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalOutcome proto.InternalMessageInfo + +type isProposalOutcome_Outcome interface { + isProposalOutcome_Outcome() + MarshalTo([]byte) (int, error) + Size() int +} + +type ProposalOutcome_Passed_ struct { + Passed *ProposalOutcome_Passed `protobuf:"bytes,1,opt,name=passed,proto3,oneof" json:"passed,omitempty"` +} +type ProposalOutcome_Failed_ struct { + Failed *ProposalOutcome_Failed `protobuf:"bytes,2,opt,name=failed,proto3,oneof" json:"failed,omitempty"` +} +type ProposalOutcome_Slashed_ struct { + Slashed *ProposalOutcome_Slashed `protobuf:"bytes,3,opt,name=slashed,proto3,oneof" json:"slashed,omitempty"` +} + +func (*ProposalOutcome_Passed_) isProposalOutcome_Outcome() {} +func (*ProposalOutcome_Failed_) isProposalOutcome_Outcome() {} +func (*ProposalOutcome_Slashed_) isProposalOutcome_Outcome() {} + +func (m *ProposalOutcome) GetOutcome() isProposalOutcome_Outcome { + if m != nil { + return m.Outcome + } + return nil +} + +func (m *ProposalOutcome) GetPassed() *ProposalOutcome_Passed { + if x, ok := m.GetOutcome().(*ProposalOutcome_Passed_); ok { + return x.Passed + } + return nil +} + +func (m *ProposalOutcome) GetFailed() *ProposalOutcome_Failed { + if x, ok := m.GetOutcome().(*ProposalOutcome_Failed_); ok { + return x.Failed + } + return nil +} + +func (m *ProposalOutcome) GetSlashed() *ProposalOutcome_Slashed { + if x, ok := m.GetOutcome().(*ProposalOutcome_Slashed_); ok { + return x.Slashed + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ProposalOutcome) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ProposalOutcome_Passed_)(nil), + (*ProposalOutcome_Failed_)(nil), + (*ProposalOutcome_Slashed_)(nil), + } +} + +// Whether or not the proposal was withdrawn. +type ProposalOutcome_Withdrawn struct { + // The reason for withdrawing the proposal during the voting period. + Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` +} + +func (m *ProposalOutcome_Withdrawn) Reset() { *m = ProposalOutcome_Withdrawn{} } +func (m *ProposalOutcome_Withdrawn) String() string { return proto.CompactTextString(m) } +func (*ProposalOutcome_Withdrawn) ProtoMessage() {} +func (*ProposalOutcome_Withdrawn) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{16, 0} +} +func (m *ProposalOutcome_Withdrawn) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalOutcome_Withdrawn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalOutcome_Withdrawn.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 *ProposalOutcome_Withdrawn) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalOutcome_Withdrawn.Merge(m, src) +} +func (m *ProposalOutcome_Withdrawn) XXX_Size() int { + return m.Size() +} +func (m *ProposalOutcome_Withdrawn) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalOutcome_Withdrawn.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalOutcome_Withdrawn proto.InternalMessageInfo + +func (m *ProposalOutcome_Withdrawn) GetReason() string { + if m != nil { + return m.Reason + } + return "" +} + +// The proposal was passed. +type ProposalOutcome_Passed struct { +} + +func (m *ProposalOutcome_Passed) Reset() { *m = ProposalOutcome_Passed{} } +func (m *ProposalOutcome_Passed) String() string { return proto.CompactTextString(m) } +func (*ProposalOutcome_Passed) ProtoMessage() {} +func (*ProposalOutcome_Passed) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{16, 1} +} +func (m *ProposalOutcome_Passed) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalOutcome_Passed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalOutcome_Passed.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 *ProposalOutcome_Passed) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalOutcome_Passed.Merge(m, src) +} +func (m *ProposalOutcome_Passed) XXX_Size() int { + return m.Size() +} +func (m *ProposalOutcome_Passed) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalOutcome_Passed.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalOutcome_Passed proto.InternalMessageInfo + +// The proposal did not pass. +type ProposalOutcome_Failed struct { + // Present if the proposal was withdrawn during the voting period. + Withdrawn *ProposalOutcome_Withdrawn `protobuf:"bytes,1,opt,name=withdrawn,proto3" json:"withdrawn,omitempty"` +} + +func (m *ProposalOutcome_Failed) Reset() { *m = ProposalOutcome_Failed{} } +func (m *ProposalOutcome_Failed) String() string { return proto.CompactTextString(m) } +func (*ProposalOutcome_Failed) ProtoMessage() {} +func (*ProposalOutcome_Failed) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{16, 2} +} +func (m *ProposalOutcome_Failed) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalOutcome_Failed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalOutcome_Failed.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 *ProposalOutcome_Failed) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalOutcome_Failed.Merge(m, src) +} +func (m *ProposalOutcome_Failed) XXX_Size() int { + return m.Size() +} +func (m *ProposalOutcome_Failed) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalOutcome_Failed.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalOutcome_Failed proto.InternalMessageInfo + +func (m *ProposalOutcome_Failed) GetWithdrawn() *ProposalOutcome_Withdrawn { + if m != nil { + return m.Withdrawn + } + return nil +} + +// The proposal did not pass, and was slashed. +type ProposalOutcome_Slashed struct { + // Present if the proposal was withdrawn during the voting period. + Withdrawn *ProposalOutcome_Withdrawn `protobuf:"bytes,1,opt,name=withdrawn,proto3" json:"withdrawn,omitempty"` +} + +func (m *ProposalOutcome_Slashed) Reset() { *m = ProposalOutcome_Slashed{} } +func (m *ProposalOutcome_Slashed) String() string { return proto.CompactTextString(m) } +func (*ProposalOutcome_Slashed) ProtoMessage() {} +func (*ProposalOutcome_Slashed) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{16, 3} +} +func (m *ProposalOutcome_Slashed) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalOutcome_Slashed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalOutcome_Slashed.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 *ProposalOutcome_Slashed) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalOutcome_Slashed.Merge(m, src) +} +func (m *ProposalOutcome_Slashed) XXX_Size() int { + return m.Size() +} +func (m *ProposalOutcome_Slashed) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalOutcome_Slashed.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalOutcome_Slashed proto.InternalMessageInfo + +func (m *ProposalOutcome_Slashed) GetWithdrawn() *ProposalOutcome_Withdrawn { + if m != nil { + return m.Withdrawn + } + return nil +} + +// A tally of votes on a proposal. +type Tally struct { + // The number of votes in favor of the proposal. + Yes uint64 `protobuf:"varint,1,opt,name=yes,proto3" json:"yes,omitempty"` + // The number of votes against the proposal. + No uint64 `protobuf:"varint,2,opt,name=no,proto3" json:"no,omitempty"` + // The number of abstentions. + Abstain uint64 `protobuf:"varint,3,opt,name=abstain,proto3" json:"abstain,omitempty"` +} + +func (m *Tally) Reset() { *m = Tally{} } +func (m *Tally) String() string { return proto.CompactTextString(m) } +func (*Tally) ProtoMessage() {} +func (*Tally) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{17} +} +func (m *Tally) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Tally) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Tally.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 *Tally) XXX_Merge(src proto.Message) { + xxx_messageInfo_Tally.Merge(m, src) +} +func (m *Tally) XXX_Size() int { + return m.Size() +} +func (m *Tally) XXX_DiscardUnknown() { + xxx_messageInfo_Tally.DiscardUnknown(m) +} + +var xxx_messageInfo_Tally proto.InternalMessageInfo + +func (m *Tally) GetYes() uint64 { + if m != nil { + return m.Yes + } + return 0 +} + +func (m *Tally) GetNo() uint64 { + if m != nil { + return m.No + } + return 0 +} + +func (m *Tally) GetAbstain() uint64 { + if m != nil { + return m.Abstain + } + return 0 +} + +// A proposal to be voted upon. +type Proposal struct { + // The unique identifier of the proposal. + Id uint64 `protobuf:"varint,4,opt,name=id,proto3" json:"id,omitempty"` + // A short title for the proposal. + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // A natural-language description of the effect of the proposal and its justification. + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // The different kinds of proposal. Only one of these should be set. + Signaling *Proposal_Signaling `protobuf:"bytes,5,opt,name=signaling,proto3" json:"signaling,omitempty"` + Emergency *Proposal_Emergency `protobuf:"bytes,6,opt,name=emergency,proto3" json:"emergency,omitempty"` + ParameterChange *Proposal_ParameterChange `protobuf:"bytes,7,opt,name=parameter_change,json=parameterChange,proto3" json:"parameter_change,omitempty"` + CommunityPoolSpend *Proposal_CommunityPoolSpend `protobuf:"bytes,8,opt,name=community_pool_spend,json=communityPoolSpend,proto3" json:"community_pool_spend,omitempty"` + UpgradePlan *Proposal_UpgradePlan `protobuf:"bytes,9,opt,name=upgrade_plan,json=upgradePlan,proto3" json:"upgrade_plan,omitempty"` + FreezeIbcClient *Proposal_FreezeIbcClient `protobuf:"bytes,10,opt,name=freeze_ibc_client,json=freezeIbcClient,proto3" json:"freeze_ibc_client,omitempty"` + UnfreezeIbcClient *Proposal_UnfreezeIbcClient `protobuf:"bytes,11,opt,name=unfreeze_ibc_client,json=unfreezeIbcClient,proto3" json:"unfreeze_ibc_client,omitempty"` +} + +func (m *Proposal) Reset() { *m = Proposal{} } +func (m *Proposal) String() string { return proto.CompactTextString(m) } +func (*Proposal) ProtoMessage() {} +func (*Proposal) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{18} +} +func (m *Proposal) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Proposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Proposal.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 *Proposal) XXX_Merge(src proto.Message) { + xxx_messageInfo_Proposal.Merge(m, src) +} +func (m *Proposal) XXX_Size() int { + return m.Size() +} +func (m *Proposal) XXX_DiscardUnknown() { + xxx_messageInfo_Proposal.DiscardUnknown(m) +} + +var xxx_messageInfo_Proposal proto.InternalMessageInfo + +func (m *Proposal) GetId() uint64 { + if m != nil { + return m.Id + } + return 0 +} + +func (m *Proposal) GetTitle() string { + if m != nil { + return m.Title + } + return "" +} + +func (m *Proposal) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *Proposal) GetSignaling() *Proposal_Signaling { + if m != nil { + return m.Signaling + } + return nil +} + +func (m *Proposal) GetEmergency() *Proposal_Emergency { + if m != nil { + return m.Emergency + } + return nil +} + +func (m *Proposal) GetParameterChange() *Proposal_ParameterChange { + if m != nil { + return m.ParameterChange + } + return nil +} + +func (m *Proposal) GetCommunityPoolSpend() *Proposal_CommunityPoolSpend { + if m != nil { + return m.CommunityPoolSpend + } + return nil +} + +func (m *Proposal) GetUpgradePlan() *Proposal_UpgradePlan { + if m != nil { + return m.UpgradePlan + } + return nil +} + +func (m *Proposal) GetFreezeIbcClient() *Proposal_FreezeIbcClient { + if m != nil { + return m.FreezeIbcClient + } + return nil +} + +func (m *Proposal) GetUnfreezeIbcClient() *Proposal_UnfreezeIbcClient { + if m != nil { + return m.UnfreezeIbcClient + } + return nil +} + +// A signaling proposal is meant to register a vote on-chain, but does not have an automatic +// effect when passed. +// +// It optionally contains a reference to a commit which contains code to upgrade the chain. +type Proposal_Signaling struct { + // The commit to be voted upon, if any is relevant. + Commit string `protobuf:"bytes,1,opt,name=commit,proto3" json:"commit,omitempty"` +} + +func (m *Proposal_Signaling) Reset() { *m = Proposal_Signaling{} } +func (m *Proposal_Signaling) String() string { return proto.CompactTextString(m) } +func (*Proposal_Signaling) ProtoMessage() {} +func (*Proposal_Signaling) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{18, 0} +} +func (m *Proposal_Signaling) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Proposal_Signaling) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Proposal_Signaling.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 *Proposal_Signaling) XXX_Merge(src proto.Message) { + xxx_messageInfo_Proposal_Signaling.Merge(m, src) +} +func (m *Proposal_Signaling) XXX_Size() int { + return m.Size() +} +func (m *Proposal_Signaling) XXX_DiscardUnknown() { + xxx_messageInfo_Proposal_Signaling.DiscardUnknown(m) +} + +var xxx_messageInfo_Proposal_Signaling proto.InternalMessageInfo + +func (m *Proposal_Signaling) GetCommit() string { + if m != nil { + return m.Commit + } + return "" +} + +// An emergency proposal can be passed instantaneously by a 2/3 majority of validators, without +// waiting for the voting period to expire. +// +// If the boolean `halt_chain` is set to `true`, then the chain will halt immediately when the +// proposal is passed. +type Proposal_Emergency struct { + // If `true`, the chain will halt immediately when the proposal is passed. + HaltChain bool `protobuf:"varint,1,opt,name=halt_chain,json=haltChain,proto3" json:"halt_chain,omitempty"` +} + +func (m *Proposal_Emergency) Reset() { *m = Proposal_Emergency{} } +func (m *Proposal_Emergency) String() string { return proto.CompactTextString(m) } +func (*Proposal_Emergency) ProtoMessage() {} +func (*Proposal_Emergency) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{18, 1} +} +func (m *Proposal_Emergency) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Proposal_Emergency) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Proposal_Emergency.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 *Proposal_Emergency) XXX_Merge(src proto.Message) { + xxx_messageInfo_Proposal_Emergency.Merge(m, src) +} +func (m *Proposal_Emergency) XXX_Size() int { + return m.Size() +} +func (m *Proposal_Emergency) XXX_DiscardUnknown() { + xxx_messageInfo_Proposal_Emergency.DiscardUnknown(m) +} + +var xxx_messageInfo_Proposal_Emergency proto.InternalMessageInfo + +func (m *Proposal_Emergency) GetHaltChain() bool { + if m != nil { + return m.HaltChain + } + return false +} + +// A parameter change proposal describes a replacement of the app parameters, which should take +// effect when the proposal is passed. +type Proposal_ParameterChange struct { + // The old app parameters to be replaced: even if the proposal passes, the update will not be + // applied if the app parameters have changed *at all* from these app parameters. Usually, + // this should be set to the current app parameters at time of proposal. + OldParameters *ChangedAppParameters `protobuf:"bytes,1,opt,name=old_parameters,json=oldParameters,proto3" json:"old_parameters,omitempty"` + // The new app parameters to be set: the *entire* app parameters will be replaced with these + // at the time the proposal is passed, for every component's parameters that is set. If a component's + // parameters are not set, then they were not changed by the proposal, and will not be updated. + NewParameters *ChangedAppParameters `protobuf:"bytes,2,opt,name=new_parameters,json=newParameters,proto3" json:"new_parameters,omitempty"` +} + +func (m *Proposal_ParameterChange) Reset() { *m = Proposal_ParameterChange{} } +func (m *Proposal_ParameterChange) String() string { return proto.CompactTextString(m) } +func (*Proposal_ParameterChange) ProtoMessage() {} +func (*Proposal_ParameterChange) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{18, 2} +} +func (m *Proposal_ParameterChange) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Proposal_ParameterChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Proposal_ParameterChange.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 *Proposal_ParameterChange) XXX_Merge(src proto.Message) { + xxx_messageInfo_Proposal_ParameterChange.Merge(m, src) +} +func (m *Proposal_ParameterChange) XXX_Size() int { + return m.Size() +} +func (m *Proposal_ParameterChange) XXX_DiscardUnknown() { + xxx_messageInfo_Proposal_ParameterChange.DiscardUnknown(m) +} + +var xxx_messageInfo_Proposal_ParameterChange proto.InternalMessageInfo + +func (m *Proposal_ParameterChange) GetOldParameters() *ChangedAppParameters { + if m != nil { + return m.OldParameters + } + return nil +} + +func (m *Proposal_ParameterChange) GetNewParameters() *ChangedAppParameters { + if m != nil { + return m.NewParameters + } + return nil +} + +// A Community Pool spend proposal describes zero or more transactions to execute on behalf of the Community Pool, with +// access to its funds, and zero or more scheduled transactions from previous passed proposals to +// cancel. +type Proposal_CommunityPoolSpend struct { + // The transaction plan to be executed at the time the proposal is passed. This must be a + // transaction plan which can be executed by the Community Pool, which means it can't require any witness + // data or authorization signatures, but it may use the `CommunityPoolSpend` action. + TransactionPlan *types.Any `protobuf:"bytes,2,opt,name=transaction_plan,json=transactionPlan,proto3" json:"transaction_plan,omitempty"` +} + +func (m *Proposal_CommunityPoolSpend) Reset() { *m = Proposal_CommunityPoolSpend{} } +func (m *Proposal_CommunityPoolSpend) String() string { return proto.CompactTextString(m) } +func (*Proposal_CommunityPoolSpend) ProtoMessage() {} +func (*Proposal_CommunityPoolSpend) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{18, 3} +} +func (m *Proposal_CommunityPoolSpend) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Proposal_CommunityPoolSpend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Proposal_CommunityPoolSpend.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 *Proposal_CommunityPoolSpend) XXX_Merge(src proto.Message) { + xxx_messageInfo_Proposal_CommunityPoolSpend.Merge(m, src) +} +func (m *Proposal_CommunityPoolSpend) XXX_Size() int { + return m.Size() +} +func (m *Proposal_CommunityPoolSpend) XXX_DiscardUnknown() { + xxx_messageInfo_Proposal_CommunityPoolSpend.DiscardUnknown(m) +} + +var xxx_messageInfo_Proposal_CommunityPoolSpend proto.InternalMessageInfo + +func (m *Proposal_CommunityPoolSpend) GetTransactionPlan() *types.Any { + if m != nil { + return m.TransactionPlan + } + return nil +} + +// An upgrade plan describes a candidate upgrade to be executed at a certain height. If passed, the chain +// will halt at the specified height. +type Proposal_UpgradePlan struct { + Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *Proposal_UpgradePlan) Reset() { *m = Proposal_UpgradePlan{} } +func (m *Proposal_UpgradePlan) String() string { return proto.CompactTextString(m) } +func (*Proposal_UpgradePlan) ProtoMessage() {} +func (*Proposal_UpgradePlan) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{18, 4} +} +func (m *Proposal_UpgradePlan) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Proposal_UpgradePlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Proposal_UpgradePlan.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 *Proposal_UpgradePlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_Proposal_UpgradePlan.Merge(m, src) +} +func (m *Proposal_UpgradePlan) XXX_Size() int { + return m.Size() +} +func (m *Proposal_UpgradePlan) XXX_DiscardUnknown() { + xxx_messageInfo_Proposal_UpgradePlan.DiscardUnknown(m) +} + +var xxx_messageInfo_Proposal_UpgradePlan proto.InternalMessageInfo + +func (m *Proposal_UpgradePlan) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +// Freeze an existing IBC client. +type Proposal_FreezeIbcClient struct { + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` +} + +func (m *Proposal_FreezeIbcClient) Reset() { *m = Proposal_FreezeIbcClient{} } +func (m *Proposal_FreezeIbcClient) String() string { return proto.CompactTextString(m) } +func (*Proposal_FreezeIbcClient) ProtoMessage() {} +func (*Proposal_FreezeIbcClient) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{18, 5} +} +func (m *Proposal_FreezeIbcClient) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Proposal_FreezeIbcClient) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Proposal_FreezeIbcClient.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 *Proposal_FreezeIbcClient) XXX_Merge(src proto.Message) { + xxx_messageInfo_Proposal_FreezeIbcClient.Merge(m, src) +} +func (m *Proposal_FreezeIbcClient) XXX_Size() int { + return m.Size() +} +func (m *Proposal_FreezeIbcClient) XXX_DiscardUnknown() { + xxx_messageInfo_Proposal_FreezeIbcClient.DiscardUnknown(m) +} + +var xxx_messageInfo_Proposal_FreezeIbcClient proto.InternalMessageInfo + +func (m *Proposal_FreezeIbcClient) GetClientId() string { + if m != nil { + return m.ClientId + } + return "" +} + +// Unfreeze an existing IBC client. +type Proposal_UnfreezeIbcClient struct { + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` +} + +func (m *Proposal_UnfreezeIbcClient) Reset() { *m = Proposal_UnfreezeIbcClient{} } +func (m *Proposal_UnfreezeIbcClient) String() string { return proto.CompactTextString(m) } +func (*Proposal_UnfreezeIbcClient) ProtoMessage() {} +func (*Proposal_UnfreezeIbcClient) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{18, 6} +} +func (m *Proposal_UnfreezeIbcClient) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Proposal_UnfreezeIbcClient) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Proposal_UnfreezeIbcClient.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 *Proposal_UnfreezeIbcClient) XXX_Merge(src proto.Message) { + xxx_messageInfo_Proposal_UnfreezeIbcClient.Merge(m, src) +} +func (m *Proposal_UnfreezeIbcClient) XXX_Size() int { + return m.Size() +} +func (m *Proposal_UnfreezeIbcClient) XXX_DiscardUnknown() { + xxx_messageInfo_Proposal_UnfreezeIbcClient.DiscardUnknown(m) +} + +var xxx_messageInfo_Proposal_UnfreezeIbcClient proto.InternalMessageInfo + +func (m *Proposal_UnfreezeIbcClient) GetClientId() string { + if m != nil { + return m.ClientId + } + return "" +} + +type ProposalInfoRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The proposal id to request information on. + ProposalId uint64 `protobuf:"varint,2,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"` +} + +func (m *ProposalInfoRequest) Reset() { *m = ProposalInfoRequest{} } +func (m *ProposalInfoRequest) String() string { return proto.CompactTextString(m) } +func (*ProposalInfoRequest) ProtoMessage() {} +func (*ProposalInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{19} +} +func (m *ProposalInfoRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalInfoRequest.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 *ProposalInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalInfoRequest.Merge(m, src) +} +func (m *ProposalInfoRequest) XXX_Size() int { + return m.Size() +} +func (m *ProposalInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalInfoRequest proto.InternalMessageInfo + +func (m *ProposalInfoRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *ProposalInfoRequest) GetProposalId() uint64 { + if m != nil { + return m.ProposalId + } + return 0 +} + +type ProposalInfoResponse struct { + // The block height at which the proposal started voting. + StartBlockHeight uint64 `protobuf:"varint,1,opt,name=start_block_height,json=startBlockHeight,proto3" json:"start_block_height,omitempty"` + // The position of the state commitment tree at which the proposal is considered to have started voting. + StartPosition uint64 `protobuf:"varint,2,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"` +} + +func (m *ProposalInfoResponse) Reset() { *m = ProposalInfoResponse{} } +func (m *ProposalInfoResponse) String() string { return proto.CompactTextString(m) } +func (*ProposalInfoResponse) ProtoMessage() {} +func (*ProposalInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{20} +} +func (m *ProposalInfoResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalInfoResponse.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 *ProposalInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalInfoResponse.Merge(m, src) +} +func (m *ProposalInfoResponse) XXX_Size() int { + return m.Size() +} +func (m *ProposalInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalInfoResponse proto.InternalMessageInfo + +func (m *ProposalInfoResponse) GetStartBlockHeight() uint64 { + if m != nil { + return m.StartBlockHeight + } + return 0 +} + +func (m *ProposalInfoResponse) GetStartPosition() uint64 { + if m != nil { + return m.StartPosition + } + return 0 +} + +type ProposalDataRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The proposal id to request information on. + ProposalId uint64 `protobuf:"varint,2,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"` +} + +func (m *ProposalDataRequest) Reset() { *m = ProposalDataRequest{} } +func (m *ProposalDataRequest) String() string { return proto.CompactTextString(m) } +func (*ProposalDataRequest) ProtoMessage() {} +func (*ProposalDataRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{21} +} +func (m *ProposalDataRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalDataRequest.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 *ProposalDataRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalDataRequest.Merge(m, src) +} +func (m *ProposalDataRequest) XXX_Size() int { + return m.Size() +} +func (m *ProposalDataRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalDataRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalDataRequest proto.InternalMessageInfo + +func (m *ProposalDataRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *ProposalDataRequest) GetProposalId() uint64 { + if m != nil { + return m.ProposalId + } + return 0 +} + +type ProposalDataResponse struct { + // The proposal metadata. + Proposal *Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + // The block height at which the proposal started voting. + StartBlockHeight uint64 `protobuf:"varint,2,opt,name=start_block_height,json=startBlockHeight,proto3" json:"start_block_height,omitempty"` + // The block height at which the proposal ends voting. + EndBlockHeight uint64 `protobuf:"varint,3,opt,name=end_block_height,json=endBlockHeight,proto3" json:"end_block_height,omitempty"` + // The position of the state commitment tree at which the proposal is considered to have started voting. + StartPosition uint64 `protobuf:"varint,4,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"` + // The current state of the proposal. + State *ProposalState `protobuf:"bytes,5,opt,name=state,proto3" json:"state,omitempty"` + // The deposit amount paid for the proposal. + ProposalDepositAmount *v1alpha1.Amount `protobuf:"bytes,6,opt,name=proposal_deposit_amount,json=proposalDepositAmount,proto3" json:"proposal_deposit_amount,omitempty"` +} + +func (m *ProposalDataResponse) Reset() { *m = ProposalDataResponse{} } +func (m *ProposalDataResponse) String() string { return proto.CompactTextString(m) } +func (*ProposalDataResponse) ProtoMessage() {} +func (*ProposalDataResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{22} +} +func (m *ProposalDataResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalDataResponse.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 *ProposalDataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalDataResponse.Merge(m, src) +} +func (m *ProposalDataResponse) XXX_Size() int { + return m.Size() +} +func (m *ProposalDataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalDataResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalDataResponse proto.InternalMessageInfo + +func (m *ProposalDataResponse) GetProposal() *Proposal { + if m != nil { + return m.Proposal + } + return nil +} + +func (m *ProposalDataResponse) GetStartBlockHeight() uint64 { + if m != nil { + return m.StartBlockHeight + } + return 0 +} + +func (m *ProposalDataResponse) GetEndBlockHeight() uint64 { + if m != nil { + return m.EndBlockHeight + } + return 0 +} + +func (m *ProposalDataResponse) GetStartPosition() uint64 { + if m != nil { + return m.StartPosition + } + return 0 +} + +func (m *ProposalDataResponse) GetState() *ProposalState { + if m != nil { + return m.State + } + return nil +} + +func (m *ProposalDataResponse) GetProposalDepositAmount() *v1alpha1.Amount { + if m != nil { + return m.ProposalDepositAmount + } + return nil +} + +// Requests the validator rate data for a proposal. +type ProposalRateDataRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The proposal id to request information on. + ProposalId uint64 `protobuf:"varint,2,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"` +} + +func (m *ProposalRateDataRequest) Reset() { *m = ProposalRateDataRequest{} } +func (m *ProposalRateDataRequest) String() string { return proto.CompactTextString(m) } +func (*ProposalRateDataRequest) ProtoMessage() {} +func (*ProposalRateDataRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{23} +} +func (m *ProposalRateDataRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalRateDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalRateDataRequest.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 *ProposalRateDataRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalRateDataRequest.Merge(m, src) +} +func (m *ProposalRateDataRequest) XXX_Size() int { + return m.Size() +} +func (m *ProposalRateDataRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalRateDataRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalRateDataRequest proto.InternalMessageInfo + +func (m *ProposalRateDataRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *ProposalRateDataRequest) GetProposalId() uint64 { + if m != nil { + return m.ProposalId + } + return 0 +} + +// The rate data for a single validator. +type ProposalRateDataResponse struct { + RateData *v1alpha16.RateData `protobuf:"bytes,1,opt,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"` +} + +func (m *ProposalRateDataResponse) Reset() { *m = ProposalRateDataResponse{} } +func (m *ProposalRateDataResponse) String() string { return proto.CompactTextString(m) } +func (*ProposalRateDataResponse) ProtoMessage() {} +func (*ProposalRateDataResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{24} +} +func (m *ProposalRateDataResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalRateDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalRateDataResponse.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 *ProposalRateDataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalRateDataResponse.Merge(m, src) +} +func (m *ProposalRateDataResponse) XXX_Size() int { + return m.Size() +} +func (m *ProposalRateDataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalRateDataResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalRateDataResponse proto.InternalMessageInfo + +func (m *ProposalRateDataResponse) GetRateData() *v1alpha16.RateData { + if m != nil { + return m.RateData + } + return nil +} + +// Requests the list of all proposals. +type ProposalListRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // Whether to include proposals that are no longer active.; + Inactive bool `protobuf:"varint,2,opt,name=inactive,proto3" json:"inactive,omitempty"` +} + +func (m *ProposalListRequest) Reset() { *m = ProposalListRequest{} } +func (m *ProposalListRequest) String() string { return proto.CompactTextString(m) } +func (*ProposalListRequest) ProtoMessage() {} +func (*ProposalListRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{25} +} +func (m *ProposalListRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalListRequest.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 *ProposalListRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalListRequest.Merge(m, src) +} +func (m *ProposalListRequest) XXX_Size() int { + return m.Size() +} +func (m *ProposalListRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalListRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalListRequest proto.InternalMessageInfo + +func (m *ProposalListRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *ProposalListRequest) GetInactive() bool { + if m != nil { + return m.Inactive + } + return false +} + +// The data for a single proposal. +type ProposalListResponse struct { + // The proposal metadata. + Proposal *Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + // The block height at which the proposal started voting. + StartBlockHeight uint64 `protobuf:"varint,2,opt,name=start_block_height,json=startBlockHeight,proto3" json:"start_block_height,omitempty"` + // The block height at which the proposal ends voting. + EndBlockHeight uint64 `protobuf:"varint,3,opt,name=end_block_height,json=endBlockHeight,proto3" json:"end_block_height,omitempty"` + // The position of the state commitment tree at which the proposal is considered to have started voting. + StartPosition uint64 `protobuf:"varint,4,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"` + // The current state of the proposal. + State *ProposalState `protobuf:"bytes,5,opt,name=state,proto3" json:"state,omitempty"` +} + +func (m *ProposalListResponse) Reset() { *m = ProposalListResponse{} } +func (m *ProposalListResponse) String() string { return proto.CompactTextString(m) } +func (*ProposalListResponse) ProtoMessage() {} +func (*ProposalListResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{26} +} +func (m *ProposalListResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposalListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposalListResponse.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 *ProposalListResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposalListResponse.Merge(m, src) +} +func (m *ProposalListResponse) XXX_Size() int { + return m.Size() +} +func (m *ProposalListResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ProposalListResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposalListResponse proto.InternalMessageInfo + +func (m *ProposalListResponse) GetProposal() *Proposal { + if m != nil { + return m.Proposal + } + return nil +} + +func (m *ProposalListResponse) GetStartBlockHeight() uint64 { + if m != nil { + return m.StartBlockHeight + } + return 0 +} + +func (m *ProposalListResponse) GetEndBlockHeight() uint64 { + if m != nil { + return m.EndBlockHeight + } + return 0 +} + +func (m *ProposalListResponse) GetStartPosition() uint64 { + if m != nil { + return m.StartPosition + } + return 0 +} + +func (m *ProposalListResponse) GetState() *ProposalState { + if m != nil { + return m.State + } + return nil +} + +// Requests the list of all validator votes for a given proposal. +type ValidatorVotesRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The proposal id to request information on. + ProposalId uint64 `protobuf:"varint,2,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"` +} + +func (m *ValidatorVotesRequest) Reset() { *m = ValidatorVotesRequest{} } +func (m *ValidatorVotesRequest) String() string { return proto.CompactTextString(m) } +func (*ValidatorVotesRequest) ProtoMessage() {} +func (*ValidatorVotesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{27} +} +func (m *ValidatorVotesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorVotesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorVotesRequest.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 *ValidatorVotesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorVotesRequest.Merge(m, src) +} +func (m *ValidatorVotesRequest) XXX_Size() int { + return m.Size() +} +func (m *ValidatorVotesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorVotesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorVotesRequest proto.InternalMessageInfo + +func (m *ValidatorVotesRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *ValidatorVotesRequest) GetProposalId() uint64 { + if m != nil { + return m.ProposalId + } + return 0 +} + +// The data for a single validator vote. +type ValidatorVotesResponse struct { + // The vote. + Vote *Vote `protobuf:"bytes,1,opt,name=vote,proto3" json:"vote,omitempty"` + // The validator identity. + IdentityKey *v1alpha12.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` +} + +func (m *ValidatorVotesResponse) Reset() { *m = ValidatorVotesResponse{} } +func (m *ValidatorVotesResponse) String() string { return proto.CompactTextString(m) } +func (*ValidatorVotesResponse) ProtoMessage() {} +func (*ValidatorVotesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{28} +} +func (m *ValidatorVotesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorVotesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorVotesResponse.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 *ValidatorVotesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorVotesResponse.Merge(m, src) +} +func (m *ValidatorVotesResponse) XXX_Size() int { + return m.Size() +} +func (m *ValidatorVotesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorVotesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorVotesResponse proto.InternalMessageInfo + +func (m *ValidatorVotesResponse) GetVote() *Vote { + if m != nil { + return m.Vote + } + return nil +} + +func (m *ValidatorVotesResponse) GetIdentityKey() *v1alpha12.IdentityKey { + if m != nil { + return m.IdentityKey + } + return nil +} + +// Governance configuration data. +type GovernanceParameters struct { + // The number of blocks during which a proposal is voted on. + ProposalVotingBlocks uint64 `protobuf:"varint,1,opt,name=proposal_voting_blocks,json=proposalVotingBlocks,proto3" json:"proposal_voting_blocks,omitempty"` + // The deposit required to create a proposal. + ProposalDepositAmount *v1alpha1.Amount `protobuf:"bytes,2,opt,name=proposal_deposit_amount,json=proposalDepositAmount,proto3" json:"proposal_deposit_amount,omitempty"` + // The quorum required for a proposal to be considered valid, as a fraction of the total stake + // weight of the network. + ProposalValidQuorum string `protobuf:"bytes,3,opt,name=proposal_valid_quorum,json=proposalValidQuorum,proto3" json:"proposal_valid_quorum,omitempty"` + // The threshold for a proposal to pass voting, as a ratio of "yes" votes over "no" votes. + ProposalPassThreshold string `protobuf:"bytes,4,opt,name=proposal_pass_threshold,json=proposalPassThreshold,proto3" json:"proposal_pass_threshold,omitempty"` + // The threshold for a proposal to be slashed, regardless of whether the "yes" and "no" votes + // would have passed it, as a ratio of "no" votes over all total votes. + ProposalSlashThreshold string `protobuf:"bytes,5,opt,name=proposal_slash_threshold,json=proposalSlashThreshold,proto3" json:"proposal_slash_threshold,omitempty"` +} + +func (m *GovernanceParameters) Reset() { *m = GovernanceParameters{} } +func (m *GovernanceParameters) String() string { return proto.CompactTextString(m) } +func (*GovernanceParameters) ProtoMessage() {} +func (*GovernanceParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{29} +} +func (m *GovernanceParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GovernanceParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GovernanceParameters.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 *GovernanceParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_GovernanceParameters.Merge(m, src) +} +func (m *GovernanceParameters) XXX_Size() int { + return m.Size() +} +func (m *GovernanceParameters) XXX_DiscardUnknown() { + xxx_messageInfo_GovernanceParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_GovernanceParameters proto.InternalMessageInfo + +func (m *GovernanceParameters) GetProposalVotingBlocks() uint64 { + if m != nil { + return m.ProposalVotingBlocks + } + return 0 +} + +func (m *GovernanceParameters) GetProposalDepositAmount() *v1alpha1.Amount { + if m != nil { + return m.ProposalDepositAmount + } + return nil +} + +func (m *GovernanceParameters) GetProposalValidQuorum() string { + if m != nil { + return m.ProposalValidQuorum + } + return "" +} + +func (m *GovernanceParameters) GetProposalPassThreshold() string { + if m != nil { + return m.ProposalPassThreshold + } + return "" +} + +func (m *GovernanceParameters) GetProposalSlashThreshold() string { + if m != nil { + return m.ProposalSlashThreshold + } + return "" +} + +// Governance genesis state. +type GenesisContent struct { + // Governance parameters. + GovernanceParams *GovernanceParameters `protobuf:"bytes,1,opt,name=governance_params,json=governanceParams,proto3" json:"governance_params,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{30} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.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 *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetGovernanceParams() *GovernanceParameters { + if m != nil { + return m.GovernanceParams + } + return nil +} + +// Note: must be kept in sync with AppParameters. +// Each field here is optional. +type ChangedAppParameters struct { + // Chain module parameters. + ChainParams *v1alpha17.ChainParameters `protobuf:"bytes,1,opt,name=chain_params,json=chainParams,proto3" json:"chain_params,omitempty"` + // Community Pool module parameters. + CommunityPoolParams *v1alpha18.CommunityPoolParameters `protobuf:"bytes,2,opt,name=community_pool_params,json=communityPoolParams,proto3" json:"community_pool_params,omitempty"` + // Governance module parameters. + GovernanceParams *GovernanceParameters `protobuf:"bytes,3,opt,name=governance_params,json=governanceParams,proto3" json:"governance_params,omitempty"` + // IBC module parameters. + IbcParams *v1alpha19.IbcParameters `protobuf:"bytes,4,opt,name=ibc_params,json=ibcParams,proto3" json:"ibc_params,omitempty"` + // Stake module parameters. + StakeParams *v1alpha16.StakeParameters `protobuf:"bytes,5,opt,name=stake_params,json=stakeParams,proto3" json:"stake_params,omitempty"` + // Fee module parameters. + FeeParams *v1alpha110.FeeParameters `protobuf:"bytes,6,opt,name=fee_params,json=feeParams,proto3" json:"fee_params,omitempty"` + // Distributions module parameters. + DistributionsParams *v1alpha111.DistributionsParameters `protobuf:"bytes,7,opt,name=distributions_params,json=distributionsParams,proto3" json:"distributions_params,omitempty"` +} + +func (m *ChangedAppParameters) Reset() { *m = ChangedAppParameters{} } +func (m *ChangedAppParameters) String() string { return proto.CompactTextString(m) } +func (*ChangedAppParameters) ProtoMessage() {} +func (*ChangedAppParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{31} +} +func (m *ChangedAppParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChangedAppParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChangedAppParameters.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 *ChangedAppParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangedAppParameters.Merge(m, src) +} +func (m *ChangedAppParameters) XXX_Size() int { + return m.Size() +} +func (m *ChangedAppParameters) XXX_DiscardUnknown() { + xxx_messageInfo_ChangedAppParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_ChangedAppParameters proto.InternalMessageInfo + +func (m *ChangedAppParameters) GetChainParams() *v1alpha17.ChainParameters { + if m != nil { + return m.ChainParams + } + return nil +} + +func (m *ChangedAppParameters) GetCommunityPoolParams() *v1alpha18.CommunityPoolParameters { + if m != nil { + return m.CommunityPoolParams + } + return nil +} + +func (m *ChangedAppParameters) GetGovernanceParams() *GovernanceParameters { + if m != nil { + return m.GovernanceParams + } + return nil +} + +func (m *ChangedAppParameters) GetIbcParams() *v1alpha19.IbcParameters { + if m != nil { + return m.IbcParams + } + return nil +} + +func (m *ChangedAppParameters) GetStakeParams() *v1alpha16.StakeParameters { + if m != nil { + return m.StakeParams + } + return nil +} + +func (m *ChangedAppParameters) GetFeeParams() *v1alpha110.FeeParameters { + if m != nil { + return m.FeeParams + } + return nil +} + +func (m *ChangedAppParameters) GetDistributionsParams() *v1alpha111.DistributionsParameters { + if m != nil { + return m.DistributionsParams + } + return nil +} + +type ChangedAppParametersSet struct { + // The set of app parameters at the time the proposal was submitted. + Old *ChangedAppParameters `protobuf:"bytes,1,opt,name=old,proto3" json:"old,omitempty"` + // The new set of parameters the proposal is trying to enact. + New *ChangedAppParameters `protobuf:"bytes,2,opt,name=new,proto3" json:"new,omitempty"` +} + +func (m *ChangedAppParametersSet) Reset() { *m = ChangedAppParametersSet{} } +func (m *ChangedAppParametersSet) String() string { return proto.CompactTextString(m) } +func (*ChangedAppParametersSet) ProtoMessage() {} +func (*ChangedAppParametersSet) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{32} +} +func (m *ChangedAppParametersSet) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChangedAppParametersSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChangedAppParametersSet.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 *ChangedAppParametersSet) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangedAppParametersSet.Merge(m, src) +} +func (m *ChangedAppParametersSet) XXX_Size() int { + return m.Size() +} +func (m *ChangedAppParametersSet) XXX_DiscardUnknown() { + xxx_messageInfo_ChangedAppParametersSet.DiscardUnknown(m) +} + +var xxx_messageInfo_ChangedAppParametersSet proto.InternalMessageInfo + +func (m *ChangedAppParametersSet) GetOld() *ChangedAppParameters { + if m != nil { + return m.Old + } + return nil +} + +func (m *ChangedAppParametersSet) GetNew() *ChangedAppParameters { + if m != nil { + return m.New + } + return nil +} + +type VotingPowerAtProposalStartRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The proposal id to request information on. + ProposalId uint64 `protobuf:"varint,2,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"` + // The validator identity key to request information on. + IdentityKey *v1alpha12.IdentityKey `protobuf:"bytes,3,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` +} + +func (m *VotingPowerAtProposalStartRequest) Reset() { *m = VotingPowerAtProposalStartRequest{} } +func (m *VotingPowerAtProposalStartRequest) String() string { return proto.CompactTextString(m) } +func (*VotingPowerAtProposalStartRequest) ProtoMessage() {} +func (*VotingPowerAtProposalStartRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{33} +} +func (m *VotingPowerAtProposalStartRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *VotingPowerAtProposalStartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_VotingPowerAtProposalStartRequest.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 *VotingPowerAtProposalStartRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_VotingPowerAtProposalStartRequest.Merge(m, src) +} +func (m *VotingPowerAtProposalStartRequest) XXX_Size() int { + return m.Size() +} +func (m *VotingPowerAtProposalStartRequest) XXX_DiscardUnknown() { + xxx_messageInfo_VotingPowerAtProposalStartRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_VotingPowerAtProposalStartRequest proto.InternalMessageInfo + +func (m *VotingPowerAtProposalStartRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *VotingPowerAtProposalStartRequest) GetProposalId() uint64 { + if m != nil { + return m.ProposalId + } + return 0 +} + +func (m *VotingPowerAtProposalStartRequest) GetIdentityKey() *v1alpha12.IdentityKey { + if m != nil { + return m.IdentityKey + } + return nil +} + +type VotingPowerAtProposalStartResponse struct { + // The voting power for the given identity key at the start of the proposal. + // TODO: since we don't support optional fields in our protos any more, + // this will be set to 0 if the validator was not active at the start of the proposal. + // Is this potentially an issue? + VotingPower uint64 `protobuf:"varint,1,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"` +} + +func (m *VotingPowerAtProposalStartResponse) Reset() { *m = VotingPowerAtProposalStartResponse{} } +func (m *VotingPowerAtProposalStartResponse) String() string { return proto.CompactTextString(m) } +func (*VotingPowerAtProposalStartResponse) ProtoMessage() {} +func (*VotingPowerAtProposalStartResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{34} +} +func (m *VotingPowerAtProposalStartResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *VotingPowerAtProposalStartResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_VotingPowerAtProposalStartResponse.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 *VotingPowerAtProposalStartResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_VotingPowerAtProposalStartResponse.Merge(m, src) +} +func (m *VotingPowerAtProposalStartResponse) XXX_Size() int { + return m.Size() +} +func (m *VotingPowerAtProposalStartResponse) XXX_DiscardUnknown() { + xxx_messageInfo_VotingPowerAtProposalStartResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_VotingPowerAtProposalStartResponse proto.InternalMessageInfo + +func (m *VotingPowerAtProposalStartResponse) GetVotingPower() uint64 { + if m != nil { + return m.VotingPower + } + return 0 +} + +type AllTalliedDelegatorVotesForProposalRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The proposal id to request information on. + ProposalId uint64 `protobuf:"varint,2,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"` +} + +func (m *AllTalliedDelegatorVotesForProposalRequest) Reset() { + *m = AllTalliedDelegatorVotesForProposalRequest{} +} +func (m *AllTalliedDelegatorVotesForProposalRequest) String() string { + return proto.CompactTextString(m) +} +func (*AllTalliedDelegatorVotesForProposalRequest) ProtoMessage() {} +func (*AllTalliedDelegatorVotesForProposalRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{35} +} +func (m *AllTalliedDelegatorVotesForProposalRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AllTalliedDelegatorVotesForProposalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AllTalliedDelegatorVotesForProposalRequest.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 *AllTalliedDelegatorVotesForProposalRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AllTalliedDelegatorVotesForProposalRequest.Merge(m, src) +} +func (m *AllTalliedDelegatorVotesForProposalRequest) XXX_Size() int { + return m.Size() +} +func (m *AllTalliedDelegatorVotesForProposalRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AllTalliedDelegatorVotesForProposalRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_AllTalliedDelegatorVotesForProposalRequest proto.InternalMessageInfo + +func (m *AllTalliedDelegatorVotesForProposalRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *AllTalliedDelegatorVotesForProposalRequest) GetProposalId() uint64 { + if m != nil { + return m.ProposalId + } + return 0 +} + +type AllTalliedDelegatorVotesForProposalResponse struct { + // The tally of delegator votes for a given validator for the proposal. + Tally *Tally `protobuf:"bytes,1,opt,name=tally,proto3" json:"tally,omitempty"` + // The validator identity associated with the tally. + IdentityKey *v1alpha12.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` +} + +func (m *AllTalliedDelegatorVotesForProposalResponse) Reset() { + *m = AllTalliedDelegatorVotesForProposalResponse{} +} +func (m *AllTalliedDelegatorVotesForProposalResponse) String() string { + return proto.CompactTextString(m) +} +func (*AllTalliedDelegatorVotesForProposalResponse) ProtoMessage() {} +func (*AllTalliedDelegatorVotesForProposalResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{36} +} +func (m *AllTalliedDelegatorVotesForProposalResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AllTalliedDelegatorVotesForProposalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AllTalliedDelegatorVotesForProposalResponse.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 *AllTalliedDelegatorVotesForProposalResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AllTalliedDelegatorVotesForProposalResponse.Merge(m, src) +} +func (m *AllTalliedDelegatorVotesForProposalResponse) XXX_Size() int { + return m.Size() +} +func (m *AllTalliedDelegatorVotesForProposalResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AllTalliedDelegatorVotesForProposalResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_AllTalliedDelegatorVotesForProposalResponse proto.InternalMessageInfo + +func (m *AllTalliedDelegatorVotesForProposalResponse) GetTally() *Tally { + if m != nil { + return m.Tally + } + return nil +} + +func (m *AllTalliedDelegatorVotesForProposalResponse) GetIdentityKey() *v1alpha12.IdentityKey { + if m != nil { + return m.IdentityKey + } + return nil +} + +type NextProposalIdRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` +} + +func (m *NextProposalIdRequest) Reset() { *m = NextProposalIdRequest{} } +func (m *NextProposalIdRequest) String() string { return proto.CompactTextString(m) } +func (*NextProposalIdRequest) ProtoMessage() {} +func (*NextProposalIdRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{37} +} +func (m *NextProposalIdRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NextProposalIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NextProposalIdRequest.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 *NextProposalIdRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_NextProposalIdRequest.Merge(m, src) +} +func (m *NextProposalIdRequest) XXX_Size() int { + return m.Size() +} +func (m *NextProposalIdRequest) XXX_DiscardUnknown() { + xxx_messageInfo_NextProposalIdRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_NextProposalIdRequest proto.InternalMessageInfo + +func (m *NextProposalIdRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +type NextProposalIdResponse struct { + // The next proposal ID. + NextProposalId uint64 `protobuf:"varint,1,opt,name=next_proposal_id,json=nextProposalId,proto3" json:"next_proposal_id,omitempty"` +} + +func (m *NextProposalIdResponse) Reset() { *m = NextProposalIdResponse{} } +func (m *NextProposalIdResponse) String() string { return proto.CompactTextString(m) } +func (*NextProposalIdResponse) ProtoMessage() {} +func (*NextProposalIdResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_67f269dcda22019a, []int{38} +} +func (m *NextProposalIdResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NextProposalIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NextProposalIdResponse.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 *NextProposalIdResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_NextProposalIdResponse.Merge(m, src) +} +func (m *NextProposalIdResponse) XXX_Size() int { + return m.Size() +} +func (m *NextProposalIdResponse) XXX_DiscardUnknown() { + xxx_messageInfo_NextProposalIdResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_NextProposalIdResponse proto.InternalMessageInfo + +func (m *NextProposalIdResponse) GetNextProposalId() uint64 { + if m != nil { + return m.NextProposalId + } + return 0 +} + +func init() { + proto.RegisterEnum("penumbra.core.component.governance.v1alpha1.Vote_Vote", Vote_Vote_name, Vote_Vote_value) + proto.RegisterType((*ZKDelegatorVoteProof)(nil), "penumbra.core.component.governance.v1alpha1.ZKDelegatorVoteProof") + proto.RegisterType((*ProposalSubmit)(nil), "penumbra.core.component.governance.v1alpha1.ProposalSubmit") + proto.RegisterType((*ProposalWithdraw)(nil), "penumbra.core.component.governance.v1alpha1.ProposalWithdraw") + proto.RegisterType((*ProposalDepositClaim)(nil), "penumbra.core.component.governance.v1alpha1.ProposalDepositClaim") + proto.RegisterType((*ValidatorVote)(nil), "penumbra.core.component.governance.v1alpha1.ValidatorVote") + proto.RegisterType((*ValidatorVoteReason)(nil), "penumbra.core.component.governance.v1alpha1.ValidatorVoteReason") + proto.RegisterType((*ValidatorVoteBody)(nil), "penumbra.core.component.governance.v1alpha1.ValidatorVoteBody") + proto.RegisterType((*DelegatorVote)(nil), "penumbra.core.component.governance.v1alpha1.DelegatorVote") + proto.RegisterType((*DelegatorVoteBody)(nil), "penumbra.core.component.governance.v1alpha1.DelegatorVoteBody") + proto.RegisterType((*DelegatorVoteView)(nil), "penumbra.core.component.governance.v1alpha1.DelegatorVoteView") + proto.RegisterType((*DelegatorVoteView_Visible)(nil), "penumbra.core.component.governance.v1alpha1.DelegatorVoteView.Visible") + proto.RegisterType((*DelegatorVoteView_Opaque)(nil), "penumbra.core.component.governance.v1alpha1.DelegatorVoteView.Opaque") + proto.RegisterType((*DelegatorVotePlan)(nil), "penumbra.core.component.governance.v1alpha1.DelegatorVotePlan") + proto.RegisterType((*CommunityPoolDeposit)(nil), "penumbra.core.component.governance.v1alpha1.CommunityPoolDeposit") + proto.RegisterType((*CommunityPoolSpend)(nil), "penumbra.core.component.governance.v1alpha1.CommunityPoolSpend") + proto.RegisterType((*CommunityPoolOutput)(nil), "penumbra.core.component.governance.v1alpha1.CommunityPoolOutput") + proto.RegisterType((*Vote)(nil), "penumbra.core.component.governance.v1alpha1.Vote") + proto.RegisterType((*ProposalState)(nil), "penumbra.core.component.governance.v1alpha1.ProposalState") + proto.RegisterType((*ProposalState_Voting)(nil), "penumbra.core.component.governance.v1alpha1.ProposalState.Voting") + proto.RegisterType((*ProposalState_Withdrawn)(nil), "penumbra.core.component.governance.v1alpha1.ProposalState.Withdrawn") + proto.RegisterType((*ProposalState_Finished)(nil), "penumbra.core.component.governance.v1alpha1.ProposalState.Finished") + proto.RegisterType((*ProposalState_Claimed)(nil), "penumbra.core.component.governance.v1alpha1.ProposalState.Claimed") + proto.RegisterType((*ProposalOutcome)(nil), "penumbra.core.component.governance.v1alpha1.ProposalOutcome") + proto.RegisterType((*ProposalOutcome_Withdrawn)(nil), "penumbra.core.component.governance.v1alpha1.ProposalOutcome.Withdrawn") + proto.RegisterType((*ProposalOutcome_Passed)(nil), "penumbra.core.component.governance.v1alpha1.ProposalOutcome.Passed") + proto.RegisterType((*ProposalOutcome_Failed)(nil), "penumbra.core.component.governance.v1alpha1.ProposalOutcome.Failed") + proto.RegisterType((*ProposalOutcome_Slashed)(nil), "penumbra.core.component.governance.v1alpha1.ProposalOutcome.Slashed") + proto.RegisterType((*Tally)(nil), "penumbra.core.component.governance.v1alpha1.Tally") + proto.RegisterType((*Proposal)(nil), "penumbra.core.component.governance.v1alpha1.Proposal") + proto.RegisterType((*Proposal_Signaling)(nil), "penumbra.core.component.governance.v1alpha1.Proposal.Signaling") + proto.RegisterType((*Proposal_Emergency)(nil), "penumbra.core.component.governance.v1alpha1.Proposal.Emergency") + proto.RegisterType((*Proposal_ParameterChange)(nil), "penumbra.core.component.governance.v1alpha1.Proposal.ParameterChange") + proto.RegisterType((*Proposal_CommunityPoolSpend)(nil), "penumbra.core.component.governance.v1alpha1.Proposal.CommunityPoolSpend") + proto.RegisterType((*Proposal_UpgradePlan)(nil), "penumbra.core.component.governance.v1alpha1.Proposal.UpgradePlan") + proto.RegisterType((*Proposal_FreezeIbcClient)(nil), "penumbra.core.component.governance.v1alpha1.Proposal.FreezeIbcClient") + proto.RegisterType((*Proposal_UnfreezeIbcClient)(nil), "penumbra.core.component.governance.v1alpha1.Proposal.UnfreezeIbcClient") + proto.RegisterType((*ProposalInfoRequest)(nil), "penumbra.core.component.governance.v1alpha1.ProposalInfoRequest") + proto.RegisterType((*ProposalInfoResponse)(nil), "penumbra.core.component.governance.v1alpha1.ProposalInfoResponse") + proto.RegisterType((*ProposalDataRequest)(nil), "penumbra.core.component.governance.v1alpha1.ProposalDataRequest") + proto.RegisterType((*ProposalDataResponse)(nil), "penumbra.core.component.governance.v1alpha1.ProposalDataResponse") + proto.RegisterType((*ProposalRateDataRequest)(nil), "penumbra.core.component.governance.v1alpha1.ProposalRateDataRequest") + proto.RegisterType((*ProposalRateDataResponse)(nil), "penumbra.core.component.governance.v1alpha1.ProposalRateDataResponse") + proto.RegisterType((*ProposalListRequest)(nil), "penumbra.core.component.governance.v1alpha1.ProposalListRequest") + proto.RegisterType((*ProposalListResponse)(nil), "penumbra.core.component.governance.v1alpha1.ProposalListResponse") + proto.RegisterType((*ValidatorVotesRequest)(nil), "penumbra.core.component.governance.v1alpha1.ValidatorVotesRequest") + proto.RegisterType((*ValidatorVotesResponse)(nil), "penumbra.core.component.governance.v1alpha1.ValidatorVotesResponse") + proto.RegisterType((*GovernanceParameters)(nil), "penumbra.core.component.governance.v1alpha1.GovernanceParameters") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.governance.v1alpha1.GenesisContent") + proto.RegisterType((*ChangedAppParameters)(nil), "penumbra.core.component.governance.v1alpha1.ChangedAppParameters") + proto.RegisterType((*ChangedAppParametersSet)(nil), "penumbra.core.component.governance.v1alpha1.ChangedAppParametersSet") + proto.RegisterType((*VotingPowerAtProposalStartRequest)(nil), "penumbra.core.component.governance.v1alpha1.VotingPowerAtProposalStartRequest") + proto.RegisterType((*VotingPowerAtProposalStartResponse)(nil), "penumbra.core.component.governance.v1alpha1.VotingPowerAtProposalStartResponse") + proto.RegisterType((*AllTalliedDelegatorVotesForProposalRequest)(nil), "penumbra.core.component.governance.v1alpha1.AllTalliedDelegatorVotesForProposalRequest") + proto.RegisterType((*AllTalliedDelegatorVotesForProposalResponse)(nil), "penumbra.core.component.governance.v1alpha1.AllTalliedDelegatorVotesForProposalResponse") + proto.RegisterType((*NextProposalIdRequest)(nil), "penumbra.core.component.governance.v1alpha1.NextProposalIdRequest") + proto.RegisterType((*NextProposalIdResponse)(nil), "penumbra.core.component.governance.v1alpha1.NextProposalIdResponse") +} + +func init() { + proto.RegisterFile("penumbra/core/component/governance/v1alpha1/governance.proto", fileDescriptor_67f269dcda22019a) +} + +var fileDescriptor_67f269dcda22019a = []byte{ + // 2894 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xdf, 0x6f, 0x63, 0x47, + 0xf5, 0xcf, 0x75, 0xe2, 0xd8, 0x3e, 0x49, 0x1c, 0xef, 0x6c, 0x76, 0x9b, 0xfa, 0xab, 0x6f, 0x68, + 0x6f, 0x5b, 0x14, 0xb5, 0xc5, 0xde, 0xa6, 0xa5, 0x5b, 0x42, 0xd5, 0x36, 0xf1, 0x26, 0x9b, 0xb0, + 0xdb, 0x8d, 0xf7, 0x7a, 0x37, 0x2d, 0xcb, 0x16, 0x33, 0xbe, 0x77, 0x6c, 0x0f, 0xb9, 0x9e, 0xeb, + 0xbd, 0x3f, 0x92, 0x7a, 0xc5, 0x03, 0x7f, 0x42, 0xa5, 0x16, 0x10, 0x42, 0x3c, 0xc0, 0x23, 0x42, + 0xfc, 0x01, 0x95, 0x78, 0x01, 0x1e, 0x10, 0x02, 0xd4, 0x17, 0x24, 0xc4, 0x53, 0xb5, 0x2b, 0x84, + 0xe0, 0x89, 0x3f, 0x01, 0xcd, 0xdc, 0xb9, 0xbf, 0x1c, 0xe7, 0x87, 0x7f, 0x6c, 0xc5, 0x03, 0x2f, + 0x96, 0x67, 0xee, 0x39, 0x9f, 0x73, 0xe6, 0x9c, 0x33, 0x67, 0xce, 0xb9, 0x73, 0xe1, 0xcd, 0x2e, + 0x61, 0x5e, 0xa7, 0x61, 0xe3, 0xb2, 0x6e, 0xd9, 0xa4, 0xac, 0x5b, 0x9d, 0xae, 0xc5, 0x08, 0x73, + 0xcb, 0x2d, 0xeb, 0x90, 0xd8, 0x0c, 0x33, 0x9d, 0x94, 0x0f, 0x5f, 0xc1, 0x66, 0xb7, 0x8d, 0x5f, + 0x89, 0xcd, 0x95, 0xba, 0xb6, 0xe5, 0x5a, 0xe8, 0xa5, 0x80, 0xbb, 0xc4, 0xb9, 0x4b, 0x21, 0x77, + 0x29, 0x46, 0x19, 0x70, 0x17, 0x9f, 0x6e, 0x59, 0x56, 0xcb, 0x24, 0x65, 0xc1, 0xda, 0xf0, 0x9a, + 0x65, 0xcc, 0x7a, 0x3e, 0x4e, 0x71, 0x35, 0xa9, 0x05, 0x76, 0x1c, 0xe2, 0x46, 0x62, 0xc5, 0x50, + 0x52, 0xae, 0x9d, 0xa4, 0xaf, 0xde, 0xc6, 0x94, 0x45, 0x3c, 0x62, 0x28, 0x79, 0xae, 0x9d, 0xc8, + 0x63, 0x75, 0x3a, 0x1e, 0xa3, 0x6e, 0xaf, 0xde, 0xb5, 0x2c, 0x33, 0xc6, 0x9c, 0x98, 0x97, 0x28, + 0x9b, 0x27, 0xa1, 0x18, 0xd4, 0x71, 0x6d, 0xda, 0xf0, 0x5c, 0x6a, 0x31, 0x27, 0x02, 0x49, 0x4c, + 0x4b, 0x8c, 0xd2, 0x49, 0x18, 0x4d, 0x12, 0x33, 0x73, 0x93, 0x90, 0xb3, 0xe8, 0x69, 0x43, 0x8f, + 0xe8, 0x69, 0x43, 0x3f, 0x8b, 0xde, 0xd1, 0x63, 0xf6, 0x74, 0x74, 0xf7, 0xac, 0x35, 0x39, 0x6d, + 0x4a, 0x4c, 0x83, 0x18, 0x7d, 0x86, 0x49, 0x4c, 0x9f, 0xe5, 0x11, 0xc7, 0xc5, 0x07, 0xb1, 0x55, + 0x89, 0xa1, 0xe4, 0xf9, 0x72, 0x92, 0xe7, 0x80, 0xf4, 0x62, 0x86, 0xe3, 0x23, 0x49, 0xf7, 0x7c, + 0x92, 0x8e, 0x79, 0x9d, 0x88, 0x8c, 0x79, 0x1d, 0x49, 0xb5, 0x1e, 0x51, 0xd9, 0xbd, 0xae, 0x6b, + 0x95, 0x0d, 0xa2, 0xe3, 0xe6, 0xab, 0x57, 0xaf, 0xd6, 0x6d, 0xc3, 0xc1, 0x31, 0x8f, 0xc4, 0xa7, + 0x7d, 0x5e, 0xf5, 0x65, 0x58, 0xba, 0x77, 0xe3, 0x1a, 0x31, 0x49, 0x0b, 0xbb, 0x96, 0xbd, 0x6f, + 0xb9, 0xa4, 0x6a, 0x5b, 0x56, 0x13, 0x2d, 0x41, 0x9a, 0x32, 0x46, 0xec, 0x65, 0xe5, 0x19, 0x65, + 0x75, 0x5e, 0xf3, 0x07, 0xea, 0xaf, 0x14, 0xc8, 0x57, 0x6d, 0xab, 0x6b, 0x39, 0xd8, 0xac, 0x79, + 0x8d, 0x0e, 0x75, 0xd1, 0x6d, 0xc8, 0x76, 0xe5, 0x8c, 0xa0, 0x9d, 0x5b, 0xfb, 0x6a, 0x69, 0x88, + 0x5d, 0x51, 0x0a, 0xe0, 0xb4, 0x10, 0x06, 0xed, 0x42, 0xde, 0x20, 0x5d, 0xcb, 0xa1, 0x6e, 0x1d, + 0x77, 0x2c, 0x8f, 0xb9, 0xcb, 0xd3, 0x02, 0x58, 0xed, 0x03, 0xe6, 0x16, 0x08, 0x71, 0x36, 0x04, + 0xa5, 0xb6, 0x20, 0x39, 0xfd, 0xa1, 0xba, 0x0d, 0x85, 0x40, 0xc0, 0x7b, 0xd4, 0x6d, 0x1b, 0x36, + 0x3e, 0x42, 0xc5, 0x3e, 0x8d, 0x67, 0x62, 0xa2, 0x2f, 0xc3, 0xac, 0x4d, 0xb0, 0x63, 0xb1, 0xe5, + 0xd4, 0x33, 0xca, 0x6a, 0x4e, 0x93, 0x23, 0xf5, 0x2f, 0x0a, 0x2c, 0x05, 0x40, 0xd7, 0x7c, 0x09, + 0x15, 0x13, 0xd3, 0xce, 0xa9, 0x60, 0xc7, 0xd7, 0x91, 0x1a, 0x71, 0x1d, 0x68, 0x1f, 0x32, 0x96, + 0xe7, 0xea, 0x56, 0x87, 0x48, 0x5b, 0xbc, 0x39, 0x92, 0x91, 0xf7, 0x7c, 0x0c, 0x2d, 0x00, 0x53, + 0x3f, 0x55, 0x60, 0x61, 0x1f, 0x9b, 0xd4, 0x08, 0xbc, 0x8f, 0x34, 0x98, 0x69, 0x58, 0x46, 0x4f, + 0xfa, 0xf2, 0xad, 0xa1, 0xc4, 0x24, 0x90, 0x36, 0x2d, 0xa3, 0xa7, 0x09, 0x2c, 0x74, 0x17, 0xb2, + 0xd8, 0x73, 0xdb, 0x75, 0x87, 0xb6, 0xa4, 0x09, 0xd6, 0x63, 0xb8, 0x22, 0x66, 0x4b, 0xc9, 0xe0, + 0x0c, 0x21, 0x6b, 0x5d, 0xc2, 0x8c, 0x0d, 0xcf, 0x6d, 0xd7, 0x68, 0x8b, 0x61, 0xd7, 0xb3, 0x89, + 0x96, 0xc1, 0xfe, 0x50, 0xfd, 0x0a, 0x5c, 0x4c, 0x48, 0xd4, 0x84, 0xaf, 0x62, 0x3e, 0x54, 0x12, + 0x3e, 0xfc, 0x77, 0x0a, 0x2e, 0x1c, 0xd3, 0xf0, 0x54, 0x07, 0x6e, 0xc1, 0xcc, 0xa1, 0xe5, 0x12, + 0xa9, 0xf3, 0x2b, 0xc3, 0xd9, 0x82, 0x2b, 0x24, 0xd8, 0xd1, 0x0d, 0x98, 0xa7, 0x06, 0x61, 0x2e, + 0x4f, 0xa8, 0x07, 0xa4, 0x27, 0x3d, 0xb8, 0xda, 0x07, 0x27, 0xb6, 0x7d, 0xc8, 0xbe, 0x2b, 0x19, + 0x6e, 0x90, 0x9e, 0x36, 0x47, 0xa3, 0x01, 0xba, 0x0d, 0xf9, 0x48, 0x9c, 0x80, 0x9b, 0x11, 0x70, + 0x2f, 0x9e, 0x0a, 0x77, 0x3d, 0x64, 0xe1, 0x80, 0x0b, 0xad, 0xf8, 0x10, 0xbd, 0x1f, 0x1a, 0x2c, + 0x2d, 0xa0, 0xde, 0x19, 0xdd, 0xe9, 0xbe, 0x0b, 0x42, 0x93, 0x7f, 0x9c, 0x82, 0x85, 0x44, 0x72, + 0x19, 0x2b, 0xbc, 0x12, 0x48, 0x4f, 0x3c, 0xbc, 0xd0, 0x7b, 0x90, 0xee, 0xf2, 0x5c, 0x28, 0xfd, + 0xb5, 0x31, 0x94, 0xae, 0x83, 0x92, 0xaa, 0xe6, 0xe3, 0xa9, 0xbf, 0x99, 0x86, 0x0b, 0xc7, 0xd6, + 0x72, 0x6a, 0x20, 0xbe, 0x00, 0x79, 0xc7, 0xc5, 0xb6, 0x5b, 0x17, 0x39, 0x81, 0xca, 0xf4, 0x34, + 0xa3, 0x2d, 0x88, 0xd9, 0xaa, 0x9c, 0x0c, 0xe3, 0x75, 0x7a, 0xbc, 0x78, 0xfd, 0x1a, 0xa4, 0x0f, + 0xb1, 0xe9, 0x11, 0x19, 0x59, 0xcf, 0xf5, 0xe1, 0xf8, 0xe5, 0x48, 0xdc, 0xff, 0x1e, 0xd1, 0x7c, + 0x0e, 0x74, 0x03, 0x16, 0x3d, 0xd6, 0xb0, 0x18, 0x3f, 0x23, 0x65, 0xce, 0x4b, 0x9f, 0x3b, 0xe7, + 0xe5, 0x03, 0x56, 0x99, 0xf4, 0xde, 0x85, 0x1c, 0xf3, 0x4c, 0x93, 0x36, 0x29, 0xb1, 0x97, 0x67, + 0x05, 0x4c, 0xf9, 0xc4, 0x35, 0xf1, 0x43, 0x3d, 0x04, 0xbc, 0x15, 0xb0, 0x69, 0x11, 0x02, 0xba, + 0x09, 0x29, 0xfb, 0x60, 0x39, 0x73, 0x2c, 0x7d, 0x9e, 0x1d, 0x20, 0xfb, 0xc4, 0xa6, 0x4d, 0xaa, + 0x63, 0x6e, 0x64, 0xbe, 0x7f, 0x52, 0xf6, 0x81, 0xfa, 0xc9, 0x4c, 0x9f, 0x13, 0xf7, 0x29, 0x39, + 0x42, 0x0d, 0xc8, 0x1c, 0x52, 0x87, 0x36, 0x4c, 0x22, 0x23, 0x7c, 0x7b, 0xf4, 0x08, 0xe7, 0x80, + 0xa5, 0x7d, 0x1f, 0x6d, 0x67, 0x4a, 0x0b, 0x80, 0x51, 0x1d, 0x66, 0xad, 0x2e, 0x7e, 0xe0, 0x05, + 0x79, 0x69, 0x6b, 0x4c, 0x11, 0x7b, 0x02, 0x6c, 0x67, 0x4a, 0x93, 0xb0, 0xc5, 0x4f, 0x15, 0xc8, + 0x48, 0xb9, 0x08, 0xf3, 0x33, 0x4c, 0x72, 0xd4, 0x45, 0x70, 0x29, 0xc7, 0x76, 0xd8, 0x90, 0x42, + 0xf9, 0xd9, 0x16, 0x4f, 0x09, 0x37, 0x61, 0x86, 0x45, 0x59, 0xf6, 0x8d, 0x93, 0x3d, 0x9c, 0x28, + 0xbe, 0x22, 0x5f, 0xcb, 0x75, 0x68, 0x02, 0xa5, 0x78, 0x00, 0xb3, 0xfe, 0x82, 0xbe, 0x00, 0xd5, + 0x37, 0x0b, 0xfd, 0x22, 0xd4, 0x7f, 0xf4, 0xef, 0xed, 0xaa, 0x89, 0xd9, 0x7f, 0xd1, 0xde, 0xbe, + 0x0b, 0x73, 0xa2, 0x10, 0x35, 0xea, 0xc2, 0xe6, 0xfe, 0x0e, 0x7f, 0x6d, 0x14, 0x9b, 0x6b, 0xe0, + 0x03, 0xf1, 0xff, 0xe8, 0x0a, 0x2c, 0xc5, 0x60, 0xa3, 0xa5, 0xa4, 0xc5, 0x52, 0x50, 0x44, 0x19, + 0xae, 0x67, 0x40, 0xa6, 0x98, 0x1d, 0x39, 0x53, 0xac, 0x00, 0xd8, 0x98, 0x19, 0x56, 0x87, 0x3e, + 0x24, 0xb6, 0xd8, 0xe2, 0xf3, 0x5a, 0x6c, 0x06, 0xad, 0x42, 0x41, 0xa4, 0xde, 0x7a, 0xc3, 0xa4, + 0xcc, 0xa0, 0xac, 0x55, 0xb7, 0x97, 0xb3, 0x82, 0x2a, 0x2f, 0xe6, 0x37, 0xe5, 0xb4, 0x36, 0x80, + 0xd2, 0x59, 0xce, 0x0d, 0xa0, 0xac, 0xa9, 0xb7, 0x61, 0xa9, 0x12, 0xf4, 0x49, 0x55, 0xcb, 0x0a, + 0xca, 0xc2, 0x28, 0x7b, 0x2a, 0xc3, 0x66, 0x4f, 0x75, 0x0f, 0x50, 0x02, 0x52, 0x24, 0x9f, 0x71, + 0x00, 0x3f, 0x52, 0xe0, 0x62, 0x02, 0x71, 0xcf, 0x73, 0xbb, 0xde, 0x38, 0x3a, 0xa2, 0xb7, 0x20, + 0x83, 0x0d, 0xc3, 0x26, 0x8e, 0x23, 0x37, 0xec, 0xf3, 0xa7, 0x16, 0x1e, 0x1b, 0x3e, 0xad, 0x16, + 0x30, 0xa9, 0x3f, 0x55, 0x60, 0x46, 0x6c, 0xfb, 0x6f, 0xc8, 0x80, 0xe6, 0x2a, 0xe4, 0xd7, 0x5e, + 0x1f, 0x3a, 0xa0, 0x63, 0x51, 0xad, 0xee, 0x4a, 0xcc, 0x25, 0x28, 0xec, 0xef, 0xdd, 0xd9, 0xaa, + 0xdf, 0xbd, 0x55, 0xab, 0x6e, 0x55, 0x76, 0xb7, 0x77, 0xb7, 0xae, 0x15, 0xa6, 0x50, 0x01, 0xe6, + 0xc5, 0xec, 0xc6, 0x66, 0xed, 0xce, 0xc6, 0xee, 0xad, 0x82, 0x82, 0xe6, 0x21, 0x2b, 0x66, 0xbe, + 0xb9, 0x55, 0x2b, 0xa4, 0xd0, 0x1c, 0x64, 0xc4, 0xe8, 0xd6, 0x5e, 0x61, 0x5a, 0xfd, 0x24, 0x0d, + 0x0b, 0x61, 0x8b, 0xe3, 0x62, 0x97, 0xa0, 0x6f, 0xc1, 0xec, 0xa1, 0xe5, 0x52, 0x16, 0x14, 0x17, + 0x1b, 0x23, 0x95, 0xde, 0x02, 0x8b, 0xeb, 0x4c, 0x59, 0x8b, 0xe7, 0x5a, 0x1f, 0x12, 0x19, 0x90, + 0x3b, 0x92, 0x8d, 0x09, 0x93, 0x7b, 0xfb, 0xda, 0x18, 0xf8, 0x41, 0x93, 0xc3, 0x76, 0xa6, 0xb4, + 0x08, 0x18, 0x61, 0xc8, 0x36, 0x29, 0xa3, 0x4e, 0x9b, 0x18, 0x72, 0xcb, 0x57, 0xc6, 0x10, 0xb2, + 0x2d, 0xa1, 0x76, 0xa6, 0xb4, 0x10, 0x16, 0x7d, 0x1b, 0x32, 0x3a, 0xef, 0x88, 0x88, 0x21, 0x4f, + 0xfc, 0xcd, 0x31, 0x24, 0x54, 0x7c, 0x24, 0x7e, 0xea, 0x49, 0xd0, 0x62, 0x16, 0x66, 0x7d, 0xe3, + 0x15, 0x9f, 0x83, 0x5c, 0xb8, 0xcc, 0x93, 0x8a, 0xfd, 0x62, 0x03, 0xb2, 0x81, 0x9a, 0xf1, 0xe6, + 0x49, 0x99, 0x60, 0xf3, 0x54, 0xc4, 0x90, 0x91, 0x8a, 0x3e, 0x29, 0x11, 0x9b, 0x19, 0x48, 0x3b, + 0xdc, 0x22, 0xea, 0x1f, 0x67, 0x60, 0xb1, 0x8f, 0x0a, 0x7d, 0x00, 0xb3, 0x5d, 0xbe, 0x55, 0x0d, + 0x29, 0xb3, 0x32, 0x8e, 0xcc, 0x52, 0x55, 0x40, 0xf1, 0xd0, 0xf4, 0x41, 0x39, 0x7c, 0x13, 0x53, + 0x93, 0x18, 0x32, 0xee, 0xc7, 0x83, 0xdf, 0x16, 0x50, 0x1c, 0xde, 0x07, 0x45, 0xdf, 0x81, 0x8c, + 0x63, 0x62, 0x11, 0x92, 0xe3, 0xc4, 0x7d, 0x80, 0x5f, 0xf3, 0xb1, 0x78, 0xc8, 0x48, 0xd8, 0xf3, + 0x05, 0x4a, 0x16, 0x66, 0xfd, 0x95, 0x17, 0x19, 0xcc, 0xfa, 0x4a, 0x26, 0x37, 0xe5, 0x28, 0x75, + 0x5c, 0xbf, 0x72, 0xa1, 0x1a, 0xb1, 0x4d, 0x59, 0xb4, 0x20, 0x23, 0x95, 0xfe, 0x62, 0x04, 0x6e, + 0xe6, 0xc2, 0x20, 0x55, 0x2b, 0x90, 0xbe, 0x83, 0x4d, 0xb3, 0x87, 0x0a, 0x30, 0xdd, 0x23, 0x8e, + 0x2c, 0x4a, 0xf8, 0x5f, 0x94, 0x87, 0x14, 0xb3, 0x64, 0x0d, 0x92, 0x62, 0x16, 0x5a, 0x86, 0x0c, + 0x6e, 0x38, 0x2e, 0xa6, 0x7e, 0x7e, 0x9a, 0xd1, 0x82, 0xa1, 0xfa, 0x4f, 0x80, 0x6c, 0x20, 0x98, + 0xb3, 0x51, 0x3f, 0xb9, 0xcc, 0x68, 0x29, 0x6a, 0xa0, 0x25, 0x48, 0xbb, 0xd4, 0x95, 0x75, 0x70, + 0x4e, 0xf3, 0x07, 0xe8, 0x19, 0x98, 0x33, 0x88, 0xa3, 0xdb, 0xb4, 0x1b, 0x56, 0x3a, 0x39, 0x2d, + 0x3e, 0x85, 0x3e, 0x80, 0x9c, 0xc3, 0x7b, 0x31, 0x93, 0x27, 0x5c, 0x3f, 0x93, 0xbc, 0x3d, 0x92, + 0x29, 0x4a, 0xb5, 0x00, 0x46, 0x8b, 0x10, 0x39, 0x3c, 0xe9, 0x10, 0xbb, 0x45, 0x98, 0xde, 0x93, + 0x05, 0xc7, 0x88, 0xf0, 0x5b, 0x01, 0x8c, 0x16, 0x21, 0xa2, 0x2e, 0x14, 0xba, 0xd8, 0xc6, 0x1d, + 0xe2, 0x12, 0xbb, 0xae, 0xb7, 0x31, 0x6b, 0x11, 0xd9, 0x71, 0x6c, 0x8d, 0x26, 0xa5, 0x1a, 0xa0, + 0x55, 0x04, 0x98, 0xb6, 0xd8, 0x4d, 0x4e, 0xa0, 0x87, 0xb0, 0x94, 0x7c, 0x5d, 0x5b, 0x77, 0x78, + 0xd5, 0x20, 0xca, 0x9b, 0xb9, 0xb5, 0x9d, 0xd1, 0xa4, 0x1e, 0xaf, 0x42, 0x34, 0xa4, 0x1f, 0xaf, + 0x4c, 0x0c, 0x98, 0xf7, 0xba, 0x2d, 0x1b, 0x1b, 0xa4, 0xde, 0x35, 0x31, 0x13, 0x85, 0xd2, 0xa8, + 0xe7, 0x63, 0xe9, 0xae, 0x8f, 0xc4, 0xeb, 0x65, 0x6d, 0xce, 0x8b, 0x06, 0xe8, 0x01, 0x5c, 0x68, + 0xda, 0x84, 0x3c, 0x24, 0x75, 0xda, 0xd0, 0xeb, 0xba, 0x49, 0x09, 0x73, 0x97, 0x61, 0x1c, 0xa3, + 0x6e, 0x0b, 0xb8, 0xdd, 0x86, 0x5e, 0x11, 0x60, 0xda, 0x62, 0x33, 0x39, 0x81, 0x8e, 0xe0, 0xa2, + 0xc7, 0x8e, 0x0b, 0x9d, 0x13, 0x42, 0xaf, 0x8f, 0xb8, 0x3e, 0xd6, 0x27, 0x45, 0xbb, 0xe0, 0xf5, + 0x4f, 0xf1, 0x94, 0x15, 0x86, 0x2d, 0x4f, 0x59, 0xdc, 0xe8, 0xd4, 0x0d, 0x52, 0x96, 0x3f, 0x2a, + 0xbe, 0x08, 0xb9, 0x30, 0xf8, 0xd0, 0xff, 0x03, 0xb4, 0xb1, 0xe9, 0xd6, 0xc5, 0x0b, 0x7f, 0x41, + 0x98, 0xd5, 0x72, 0x7c, 0xa6, 0xc2, 0x27, 0x8a, 0x7f, 0x57, 0x60, 0xb1, 0x2f, 0x86, 0x50, 0x1b, + 0xf2, 0x96, 0x69, 0xd4, 0xc3, 0x48, 0x72, 0x64, 0xca, 0x19, 0xce, 0x71, 0x3e, 0x98, 0xb1, 0xd1, + 0xed, 0x86, 0xf8, 0x8e, 0xb6, 0x60, 0x99, 0x46, 0x34, 0xe4, 0x92, 0x18, 0x39, 0x8a, 0x4b, 0x4a, + 0x4d, 0x4c, 0x12, 0x23, 0x47, 0xd1, 0xb0, 0x78, 0x77, 0x60, 0xe9, 0xfc, 0x36, 0x14, 0x5c, 0x1b, + 0x33, 0x07, 0xeb, 0x3c, 0xb7, 0xf8, 0x41, 0xea, 0x6b, 0xb0, 0x54, 0xf2, 0x6f, 0x63, 0x4a, 0xc1, + 0x6d, 0x4c, 0x69, 0x83, 0xf5, 0xb4, 0xc5, 0x18, 0x35, 0x8f, 0xbd, 0xe2, 0x0b, 0x30, 0x17, 0x8b, + 0x4b, 0xee, 0x91, 0x36, 0xa1, 0xad, 0xb6, 0x2b, 0x13, 0xa6, 0x1c, 0x15, 0x4b, 0xb0, 0xd8, 0x17, + 0x53, 0xe8, 0xff, 0x20, 0xe7, 0x47, 0x4d, 0x9d, 0x1a, 0xd2, 0x7f, 0x59, 0x7f, 0x62, 0xd7, 0x28, + 0x5e, 0x81, 0x0b, 0xc7, 0xc2, 0xe1, 0x54, 0x0e, 0xf5, 0x36, 0x5c, 0x0c, 0x22, 0x69, 0x97, 0x35, + 0x2d, 0x8d, 0x3c, 0xf0, 0x88, 0xe3, 0xa2, 0xa7, 0x21, 0x2b, 0x1c, 0x1f, 0xb1, 0x64, 0xc4, 0x78, + 0xd7, 0x40, 0x5f, 0x82, 0xb9, 0xa0, 0xc7, 0xe4, 0x4f, 0xfd, 0x84, 0x0e, 0xc1, 0xd4, 0xae, 0xa1, + 0x1e, 0x44, 0xaf, 0xb4, 0x7d, 0x48, 0xa7, 0x6b, 0x31, 0x87, 0xa0, 0x97, 0x01, 0xf9, 0x0d, 0x69, + 0xc3, 0xb4, 0xf4, 0x83, 0x7a, 0x62, 0xc1, 0x05, 0xf1, 0x64, 0x93, 0x3f, 0xd8, 0x11, 0xf3, 0xe7, + 0x6c, 0x5f, 0xe3, 0xfa, 0x5f, 0xc3, 0x2e, 0x9e, 0x84, 0xfe, 0x3f, 0x9c, 0x8e, 0xbd, 0x93, 0x17, + 0x98, 0x72, 0x01, 0x4f, 0xe0, 0x4a, 0x62, 0xb0, 0x4d, 0x52, 0x27, 0xd8, 0x64, 0x15, 0x0a, 0x84, + 0x19, 0x49, 0x5a, 0xff, 0xec, 0xcc, 0x13, 0x66, 0x9c, 0x6e, 0xbd, 0x99, 0x41, 0xcd, 0x7f, 0x55, + 0x96, 0x81, 0xf2, 0x40, 0x5c, 0x1f, 0xbd, 0xb4, 0xd6, 0x7c, 0x20, 0x74, 0x0f, 0x9e, 0x0a, 0xad, + 0xdb, 0x77, 0x49, 0x71, 0xfe, 0x36, 0xfc, 0x52, 0x37, 0x79, 0x25, 0x22, 0x2f, 0x5d, 0xee, 0xc2, + 0x53, 0xa1, 0x09, 0xb1, 0x4b, 0x26, 0xe5, 0x6f, 0x0a, 0xcb, 0xc7, 0x61, 0xa5, 0xcb, 0xdf, 0x85, + 0x9c, 0x8d, 0x5d, 0x52, 0x37, 0xb0, 0x8b, 0xa5, 0xcf, 0xaf, 0x9c, 0xfc, 0x52, 0x43, 0xdc, 0xc4, + 0x85, 0x8b, 0x09, 0xc1, 0xb2, 0xb6, 0xfc, 0xa7, 0xde, 0x8c, 0xa2, 0xf5, 0x26, 0x75, 0xdc, 0x73, + 0x68, 0x5f, 0x84, 0x2c, 0x65, 0x3c, 0x71, 0x1c, 0xfa, 0x2f, 0xb2, 0xb2, 0x5a, 0x38, 0x56, 0x3f, + 0x4d, 0x45, 0x81, 0xea, 0xc3, 0xfd, 0x2f, 0x50, 0xcf, 0x1b, 0xa8, 0x6a, 0x0d, 0x2e, 0x25, 0x6e, + 0x18, 0x9c, 0x49, 0x84, 0xd2, 0x2f, 0x15, 0xb8, 0xdc, 0x8f, 0x2a, 0x7d, 0xb2, 0x15, 0x7b, 0x2d, + 0x31, 0xc1, 0x3b, 0x9f, 0xd4, 0x18, 0x77, 0x3e, 0xea, 0x9f, 0x53, 0xb0, 0x14, 0xdd, 0xe0, 0xc4, + 0xce, 0xd7, 0xd7, 0xe0, 0x72, 0xb8, 0x50, 0xff, 0x85, 0x82, 0xef, 0xcb, 0xa0, 0xa0, 0x5f, 0x0a, + 0x9e, 0xfa, 0xad, 0xb3, 0x70, 0xa8, 0x73, 0xda, 0xde, 0x4f, 0x8d, 0xb9, 0xf7, 0xd1, 0x1a, 0x5c, + 0x8a, 0x34, 0xe2, 0x16, 0xae, 0x3f, 0xf0, 0x2c, 0xdb, 0xeb, 0x88, 0xb0, 0xca, 0x69, 0x17, 0x43, + 0x85, 0xf8, 0xb3, 0xdb, 0xe2, 0x11, 0x7a, 0x3d, 0xa6, 0x0f, 0xef, 0x3d, 0xeb, 0x6e, 0xdb, 0x26, + 0x4e, 0xdb, 0x32, 0xfd, 0x7e, 0x22, 0x17, 0xc9, 0xe2, 0x9d, 0xda, 0x9d, 0xe0, 0x21, 0x7a, 0x03, + 0x96, 0x43, 0x3e, 0xd1, 0xf3, 0xc5, 0x18, 0xd3, 0x82, 0x31, 0xb4, 0x8e, 0x68, 0xb4, 0x42, 0x4e, + 0xf5, 0xfb, 0x0a, 0xe4, 0xaf, 0x13, 0x46, 0x1c, 0xea, 0x54, 0x2c, 0xe6, 0xf2, 0xd3, 0x97, 0xc1, + 0x85, 0xd8, 0xbd, 0x9a, 0xa8, 0x58, 0x46, 0xab, 0x8b, 0x06, 0x39, 0x4a, 0x2b, 0xb4, 0x92, 0xb3, + 0x8e, 0xfa, 0x79, 0x1a, 0x96, 0x06, 0x15, 0x36, 0xe8, 0x1e, 0xcc, 0xfb, 0x71, 0x9d, 0xd0, 0xe1, + 0xea, 0x89, 0x3a, 0xf8, 0x5f, 0x7a, 0xc4, 0x8b, 0x25, 0xca, 0x62, 0x92, 0xe7, 0xf4, 0x70, 0xc2, + 0x41, 0xdf, 0x83, 0x4b, 0x7d, 0xcd, 0x82, 0x14, 0x92, 0x3a, 0xa3, 0x5b, 0xe8, 0xfb, 0x22, 0x24, + 0x92, 0x16, 0xaf, 0xb9, 0x62, 0x52, 0x2f, 0xea, 0xc7, 0x1e, 0x38, 0x83, 0x4d, 0x3c, 0xfd, 0xc4, + 0x4c, 0x8c, 0x34, 0x00, 0x5e, 0xbc, 0x4b, 0x41, 0xfe, 0x7b, 0xaf, 0x57, 0x4f, 0x14, 0x44, 0x1b, + 0x7a, 0x6c, 0x2b, 0x36, 0xf4, 0x18, 0x74, 0x8e, 0xca, 0xa1, 0xf0, 0x8e, 0x38, 0x3e, 0x02, 0xd4, + 0xf4, 0x19, 0xde, 0xe9, 0x3b, 0x6b, 0x6a, 0x7c, 0x18, 0xf7, 0x8e, 0x13, 0x4e, 0x08, 0x7d, 0x9b, + 0x24, 0x44, 0x9e, 0x3d, 0x43, 0xdf, 0x26, 0x89, 0xe1, 0x6e, 0x93, 0x38, 0x6a, 0xae, 0x49, 0x02, + 0xcc, 0x87, 0xb0, 0x94, 0xf8, 0x10, 0x27, 0x40, 0xcf, 0x9c, 0xd1, 0xca, 0x24, 0xbf, 0xde, 0x89, + 0x6e, 0x43, 0xe2, 0xd3, 0x71, 0x7f, 0x1b, 0xc7, 0x1e, 0x38, 0xea, 0x6f, 0x15, 0x78, 0x6a, 0x50, + 0x88, 0xd7, 0x88, 0x8b, 0x6a, 0x30, 0xcd, 0xb7, 0xe9, 0xc4, 0x1a, 0x0f, 0x8e, 0xc6, 0x41, 0x19, + 0x39, 0x9a, 0x5c, 0x8f, 0xc1, 0xd1, 0xf8, 0x59, 0xf1, 0xac, 0x9f, 0x3e, 0xab, 0xd6, 0x11, 0xb1, + 0x37, 0xdc, 0xd8, 0x31, 0x65, 0xbb, 0x13, 0x38, 0x8d, 0x26, 0xfa, 0x7d, 0x80, 0x7a, 0x1d, 0xd4, + 0xd3, 0xb4, 0x95, 0xa7, 0xdc, 0xb3, 0x30, 0x2f, 0xcf, 0x8b, 0x2e, 0x27, 0x93, 0xc7, 0xc5, 0xdc, + 0x61, 0xc4, 0xa9, 0xb6, 0xe1, 0xc5, 0x0d, 0xd3, 0xbc, 0x83, 0x4d, 0x93, 0x12, 0x23, 0x71, 0xa5, + 0xe5, 0x6c, 0x5b, 0x76, 0x58, 0x7a, 0x4c, 0xe0, 0x34, 0xfe, 0x9d, 0x02, 0x2f, 0x9d, 0x4b, 0x94, + 0x54, 0x7e, 0x07, 0xd2, 0x2e, 0x36, 0xcd, 0xe0, 0x23, 0x82, 0xb5, 0xa1, 0x1c, 0x2d, 0x5e, 0x7b, + 0x69, 0x3e, 0xc0, 0x64, 0x4f, 0xe9, 0x35, 0xb8, 0x74, 0x8b, 0x7c, 0x18, 0x1a, 0x7c, 0xd7, 0x38, + 0xdb, 0x36, 0xea, 0x26, 0x5c, 0xee, 0xe7, 0x91, 0x8b, 0x5c, 0x85, 0x02, 0x23, 0x1f, 0xba, 0xf5, + 0xb8, 0xe9, 0x7c, 0x2f, 0xe5, 0x59, 0x82, 0x63, 0xed, 0x4f, 0x00, 0xf3, 0xb7, 0x3d, 0x62, 0xf7, + 0x6a, 0xc4, 0x3e, 0xa4, 0x3a, 0x41, 0x1f, 0x2b, 0x30, 0x1f, 0xef, 0xec, 0xd0, 0x3b, 0x23, 0x95, + 0x61, 0xb1, 0x3e, 0xb3, 0xb8, 0x31, 0x06, 0x82, 0x5c, 0xd0, 0x0f, 0x62, 0x5a, 0xf1, 0x2a, 0x78, + 0x44, 0xad, 0x62, 0xf5, 0xf8, 0x88, 0x5a, 0xc5, 0x4b, 0xf0, 0x2b, 0x4a, 0xc2, 0x5a, 0xbc, 0xf8, + 0x1f, 0x51, 0xaf, 0x58, 0x97, 0x33, 0xa2, 0x5e, 0x89, 0x86, 0xe6, 0xc7, 0x0a, 0xe4, 0x93, 0x91, + 0x81, 0x86, 0xbb, 0x50, 0x19, 0x18, 0x8a, 0xc5, 0xca, 0x58, 0x18, 0x52, 0xb7, 0x9f, 0x28, 0x90, + 0x4f, 0x56, 0xcf, 0x43, 0xea, 0x36, 0xb0, 0xa0, 0x1f, 0x52, 0xb7, 0xc1, 0xe5, 0xfb, 0x15, 0x05, + 0xfd, 0x5a, 0x81, 0xe2, 0xc9, 0x19, 0x10, 0xdd, 0x1a, 0xb6, 0xa2, 0x3f, 0x3d, 0xf1, 0x17, 0xf7, + 0x26, 0x86, 0x27, 0xad, 0xfb, 0x37, 0x05, 0x9e, 0x3b, 0x47, 0x36, 0x44, 0xef, 0x0d, 0x25, 0xf8, + 0xfc, 0xa9, 0xbc, 0xf8, 0xfe, 0xe4, 0x81, 0x43, 0xe7, 0xfc, 0x4c, 0x89, 0x3e, 0xc8, 0x0c, 0xfa, + 0x6e, 0x34, 0xda, 0xc5, 0x4f, 0xdf, 0xab, 0x85, 0xe2, 0xd6, 0x98, 0x28, 0x81, 0x8e, 0x9b, 0x3f, + 0x9a, 0xfe, 0xfd, 0xa3, 0x15, 0xe5, 0xb3, 0x47, 0x2b, 0xca, 0xe7, 0x8f, 0x56, 0x94, 0x8f, 0x1e, + 0xaf, 0x4c, 0x7d, 0xf6, 0x78, 0x65, 0xea, 0xaf, 0x8f, 0x57, 0xa6, 0xa0, 0xac, 0x5b, 0x9d, 0x61, + 0xc4, 0x6c, 0x2e, 0xc6, 0x4a, 0x55, 0xdb, 0x72, 0xad, 0xaa, 0x72, 0xef, 0xbb, 0x2d, 0xea, 0xb6, + 0xbd, 0x06, 0x67, 0x2c, 0xeb, 0x96, 0xd3, 0xb1, 0x9c, 0xb2, 0x4d, 0x4c, 0xdc, 0x23, 0x76, 0xf9, + 0x70, 0x2d, 0xfc, 0x2b, 0x0e, 0x08, 0xa7, 0x3c, 0xc4, 0xd7, 0xe9, 0x5f, 0x8f, 0xe6, 0x82, 0xa9, + 0x9f, 0xa7, 0x66, 0xaa, 0x95, 0xca, 0xf5, 0x5f, 0xa4, 0x5e, 0xaa, 0x06, 0x3a, 0x57, 0xb8, 0xce, + 0x95, 0x50, 0xe7, 0x48, 0xbd, 0xd2, 0xbe, 0x64, 0xfa, 0x43, 0x44, 0x7d, 0x9f, 0x53, 0xdf, 0x0f, + 0xa9, 0xef, 0x47, 0xd4, 0xf7, 0x03, 0xea, 0x47, 0xa9, 0xab, 0x43, 0x50, 0xdf, 0xbf, 0x5e, 0xdd, + 0x7c, 0x97, 0xb8, 0xd8, 0xc0, 0x2e, 0xfe, 0x57, 0xaa, 0x1c, 0x70, 0xae, 0xaf, 0x73, 0x56, 0xfe, + 0x2b, 0x79, 0xd7, 0xd7, 0x23, 0xe6, 0xf5, 0xf5, 0x80, 0xbb, 0x31, 0x2b, 0x5e, 0xd6, 0xbe, 0xfa, + 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc6, 0x98, 0x97, 0x6a, 0xb5, 0x2f, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + ProposalInfo(ctx context.Context, in *ProposalInfoRequest, opts ...grpc.CallOption) (*ProposalInfoResponse, error) + ProposalList(ctx context.Context, in *ProposalListRequest, opts ...grpc.CallOption) (QueryService_ProposalListClient, error) + ProposalData(ctx context.Context, in *ProposalDataRequest, opts ...grpc.CallOption) (*ProposalDataResponse, error) + NextProposalId(ctx context.Context, in *NextProposalIdRequest, opts ...grpc.CallOption) (*NextProposalIdResponse, error) + ValidatorVotes(ctx context.Context, in *ValidatorVotesRequest, opts ...grpc.CallOption) (QueryService_ValidatorVotesClient, error) + VotingPowerAtProposalStart(ctx context.Context, in *VotingPowerAtProposalStartRequest, opts ...grpc.CallOption) (*VotingPowerAtProposalStartResponse, error) + AllTalliedDelegatorVotesForProposal(ctx context.Context, in *AllTalliedDelegatorVotesForProposalRequest, opts ...grpc.CallOption) (QueryService_AllTalliedDelegatorVotesForProposalClient, error) + // Used for computing voting power ? + ProposalRateData(ctx context.Context, in *ProposalRateDataRequest, opts ...grpc.CallOption) (QueryService_ProposalRateDataClient, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) ProposalInfo(ctx context.Context, in *ProposalInfoRequest, opts ...grpc.CallOption) (*ProposalInfoResponse, error) { + out := new(ProposalInfoResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.governance.v1alpha1.QueryService/ProposalInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) ProposalList(ctx context.Context, in *ProposalListRequest, opts ...grpc.CallOption) (QueryService_ProposalListClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.core.component.governance.v1alpha1.QueryService/ProposalList", opts...) + if err != nil { + return nil, err + } + x := &queryServiceProposalListClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_ProposalListClient interface { + Recv() (*ProposalListResponse, error) + grpc.ClientStream +} + +type queryServiceProposalListClient struct { + grpc.ClientStream +} + +func (x *queryServiceProposalListClient) Recv() (*ProposalListResponse, error) { + m := new(ProposalListResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *queryServiceClient) ProposalData(ctx context.Context, in *ProposalDataRequest, opts ...grpc.CallOption) (*ProposalDataResponse, error) { + out := new(ProposalDataResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.governance.v1alpha1.QueryService/ProposalData", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) NextProposalId(ctx context.Context, in *NextProposalIdRequest, opts ...grpc.CallOption) (*NextProposalIdResponse, error) { + out := new(NextProposalIdResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.governance.v1alpha1.QueryService/NextProposalId", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) ValidatorVotes(ctx context.Context, in *ValidatorVotesRequest, opts ...grpc.CallOption) (QueryService_ValidatorVotesClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[1], "/penumbra.core.component.governance.v1alpha1.QueryService/ValidatorVotes", opts...) + if err != nil { + return nil, err + } + x := &queryServiceValidatorVotesClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_ValidatorVotesClient interface { + Recv() (*ValidatorVotesResponse, error) + grpc.ClientStream +} + +type queryServiceValidatorVotesClient struct { + grpc.ClientStream +} + +func (x *queryServiceValidatorVotesClient) Recv() (*ValidatorVotesResponse, error) { + m := new(ValidatorVotesResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *queryServiceClient) VotingPowerAtProposalStart(ctx context.Context, in *VotingPowerAtProposalStartRequest, opts ...grpc.CallOption) (*VotingPowerAtProposalStartResponse, error) { + out := new(VotingPowerAtProposalStartResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.governance.v1alpha1.QueryService/VotingPowerAtProposalStart", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) AllTalliedDelegatorVotesForProposal(ctx context.Context, in *AllTalliedDelegatorVotesForProposalRequest, opts ...grpc.CallOption) (QueryService_AllTalliedDelegatorVotesForProposalClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[2], "/penumbra.core.component.governance.v1alpha1.QueryService/AllTalliedDelegatorVotesForProposal", opts...) + if err != nil { + return nil, err + } + x := &queryServiceAllTalliedDelegatorVotesForProposalClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_AllTalliedDelegatorVotesForProposalClient interface { + Recv() (*AllTalliedDelegatorVotesForProposalResponse, error) + grpc.ClientStream +} + +type queryServiceAllTalliedDelegatorVotesForProposalClient struct { + grpc.ClientStream +} + +func (x *queryServiceAllTalliedDelegatorVotesForProposalClient) Recv() (*AllTalliedDelegatorVotesForProposalResponse, error) { + m := new(AllTalliedDelegatorVotesForProposalResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *queryServiceClient) ProposalRateData(ctx context.Context, in *ProposalRateDataRequest, opts ...grpc.CallOption) (QueryService_ProposalRateDataClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[3], "/penumbra.core.component.governance.v1alpha1.QueryService/ProposalRateData", opts...) + if err != nil { + return nil, err + } + x := &queryServiceProposalRateDataClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_ProposalRateDataClient interface { + Recv() (*ProposalRateDataResponse, error) + grpc.ClientStream +} + +type queryServiceProposalRateDataClient struct { + grpc.ClientStream +} + +func (x *queryServiceProposalRateDataClient) Recv() (*ProposalRateDataResponse, error) { + m := new(ProposalRateDataResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + ProposalInfo(context.Context, *ProposalInfoRequest) (*ProposalInfoResponse, error) + ProposalList(*ProposalListRequest, QueryService_ProposalListServer) error + ProposalData(context.Context, *ProposalDataRequest) (*ProposalDataResponse, error) + NextProposalId(context.Context, *NextProposalIdRequest) (*NextProposalIdResponse, error) + ValidatorVotes(*ValidatorVotesRequest, QueryService_ValidatorVotesServer) error + VotingPowerAtProposalStart(context.Context, *VotingPowerAtProposalStartRequest) (*VotingPowerAtProposalStartResponse, error) + AllTalliedDelegatorVotesForProposal(*AllTalliedDelegatorVotesForProposalRequest, QueryService_AllTalliedDelegatorVotesForProposalServer) error + // Used for computing voting power ? + ProposalRateData(*ProposalRateDataRequest, QueryService_ProposalRateDataServer) error +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) ProposalInfo(ctx context.Context, req *ProposalInfoRequest) (*ProposalInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ProposalInfo not implemented") +} +func (*UnimplementedQueryServiceServer) ProposalList(req *ProposalListRequest, srv QueryService_ProposalListServer) error { + return status.Errorf(codes.Unimplemented, "method ProposalList not implemented") +} +func (*UnimplementedQueryServiceServer) ProposalData(ctx context.Context, req *ProposalDataRequest) (*ProposalDataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ProposalData not implemented") +} +func (*UnimplementedQueryServiceServer) NextProposalId(ctx context.Context, req *NextProposalIdRequest) (*NextProposalIdResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method NextProposalId not implemented") +} +func (*UnimplementedQueryServiceServer) ValidatorVotes(req *ValidatorVotesRequest, srv QueryService_ValidatorVotesServer) error { + return status.Errorf(codes.Unimplemented, "method ValidatorVotes not implemented") +} +func (*UnimplementedQueryServiceServer) VotingPowerAtProposalStart(ctx context.Context, req *VotingPowerAtProposalStartRequest) (*VotingPowerAtProposalStartResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method VotingPowerAtProposalStart not implemented") +} +func (*UnimplementedQueryServiceServer) AllTalliedDelegatorVotesForProposal(req *AllTalliedDelegatorVotesForProposalRequest, srv QueryService_AllTalliedDelegatorVotesForProposalServer) error { + return status.Errorf(codes.Unimplemented, "method AllTalliedDelegatorVotesForProposal not implemented") +} +func (*UnimplementedQueryServiceServer) ProposalRateData(req *ProposalRateDataRequest, srv QueryService_ProposalRateDataServer) error { + return status.Errorf(codes.Unimplemented, "method ProposalRateData not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_ProposalInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProposalInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).ProposalInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.governance.v1alpha1.QueryService/ProposalInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).ProposalInfo(ctx, req.(*ProposalInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_ProposalList_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(ProposalListRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).ProposalList(m, &queryServiceProposalListServer{stream}) +} + +type QueryService_ProposalListServer interface { + Send(*ProposalListResponse) error + grpc.ServerStream +} + +type queryServiceProposalListServer struct { + grpc.ServerStream +} + +func (x *queryServiceProposalListServer) Send(m *ProposalListResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_ProposalData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProposalDataRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).ProposalData(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.governance.v1alpha1.QueryService/ProposalData", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).ProposalData(ctx, req.(*ProposalDataRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_NextProposalId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(NextProposalIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).NextProposalId(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.governance.v1alpha1.QueryService/NextProposalId", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).NextProposalId(ctx, req.(*NextProposalIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_ValidatorVotes_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(ValidatorVotesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).ValidatorVotes(m, &queryServiceValidatorVotesServer{stream}) +} + +type QueryService_ValidatorVotesServer interface { + Send(*ValidatorVotesResponse) error + grpc.ServerStream +} + +type queryServiceValidatorVotesServer struct { + grpc.ServerStream +} + +func (x *queryServiceValidatorVotesServer) Send(m *ValidatorVotesResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_VotingPowerAtProposalStart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VotingPowerAtProposalStartRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).VotingPowerAtProposalStart(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.governance.v1alpha1.QueryService/VotingPowerAtProposalStart", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).VotingPowerAtProposalStart(ctx, req.(*VotingPowerAtProposalStartRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_AllTalliedDelegatorVotesForProposal_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(AllTalliedDelegatorVotesForProposalRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).AllTalliedDelegatorVotesForProposal(m, &queryServiceAllTalliedDelegatorVotesForProposalServer{stream}) +} + +type QueryService_AllTalliedDelegatorVotesForProposalServer interface { + Send(*AllTalliedDelegatorVotesForProposalResponse) error + grpc.ServerStream +} + +type queryServiceAllTalliedDelegatorVotesForProposalServer struct { + grpc.ServerStream +} + +func (x *queryServiceAllTalliedDelegatorVotesForProposalServer) Send(m *AllTalliedDelegatorVotesForProposalResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_ProposalRateData_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(ProposalRateDataRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).ProposalRateData(m, &queryServiceProposalRateDataServer{stream}) +} + +type QueryService_ProposalRateDataServer interface { + Send(*ProposalRateDataResponse) error + grpc.ServerStream +} + +type queryServiceProposalRateDataServer struct { + grpc.ServerStream +} + +func (x *queryServiceProposalRateDataServer) Send(m *ProposalRateDataResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.governance.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ProposalInfo", + Handler: _QueryService_ProposalInfo_Handler, + }, + { + MethodName: "ProposalData", + Handler: _QueryService_ProposalData_Handler, + }, + { + MethodName: "NextProposalId", + Handler: _QueryService_NextProposalId_Handler, + }, + { + MethodName: "VotingPowerAtProposalStart", + Handler: _QueryService_VotingPowerAtProposalStart_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "ProposalList", + Handler: _QueryService_ProposalList_Handler, + ServerStreams: true, + }, + { + StreamName: "ValidatorVotes", + Handler: _QueryService_ValidatorVotes_Handler, + ServerStreams: true, + }, + { + StreamName: "AllTalliedDelegatorVotesForProposal", + Handler: _QueryService_AllTalliedDelegatorVotesForProposal_Handler, + ServerStreams: true, + }, + { + StreamName: "ProposalRateData", + Handler: _QueryService_ProposalRateData_Handler, + ServerStreams: true, + }, + }, + Metadata: "penumbra/core/component/governance/v1alpha1/governance.proto", +} + +func (m *ZKDelegatorVoteProof) 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 *ZKDelegatorVoteProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ZKDelegatorVoteProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalSubmit) 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 *ProposalSubmit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DepositAmount != nil { + { + size, err := m.DepositAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Proposal != nil { + { + size, err := m.Proposal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalWithdraw) 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 *ProposalWithdraw) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x12 + } + if m.Proposal != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ProposalDepositClaim) 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 *ProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Outcome != nil { + { + size, err := m.Outcome.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.DepositAmount != nil { + { + size, err := m.DepositAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Proposal != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ValidatorVote) 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 *ValidatorVote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AuthSig != nil { + { + size, err := m.AuthSig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Body != nil { + { + size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorVoteReason) 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 *ValidatorVoteReason) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorVoteReason) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorVoteBody) 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 *ValidatorVoteBody) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorVoteBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Reason != nil { + { + size, err := m.Reason.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.GovernanceKey != nil { + { + size, err := m.GovernanceKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.IdentityKey != nil { + { + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Vote != nil { + { + size, err := m.Vote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Proposal != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *DelegatorVote) 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 *DelegatorVote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Proof != nil { + { + size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.AuthSig != nil { + { + size, err := m.AuthSig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Body != nil { + { + size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DelegatorVoteBody) 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 *DelegatorVoteBody) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegatorVoteBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Rk != nil { + { + size, err := m.Rk.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.Nullifier != nil { + { + size, err := m.Nullifier.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.UnbondedAmount != nil { + { + size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Vote != nil { + { + size, err := m.Vote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.StartPosition != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.StartPosition)) + i-- + dAtA[i] = 0x10 + } + if m.Proposal != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *DelegatorVoteView) 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 *DelegatorVoteView) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegatorVoteView) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DelegatorVote != nil { + { + size := m.DelegatorVote.Size() + i -= size + if _, err := m.DelegatorVote.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *DelegatorVoteView_Visible_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegatorVoteView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Visible != nil { + { + size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *DelegatorVoteView_Opaque_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegatorVoteView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Opaque != nil { + { + size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *DelegatorVoteView_Visible) 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 *DelegatorVoteView_Visible) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegatorVoteView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Note != nil { + { + size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.DelegatorVote != nil { + { + size, err := m.DelegatorVote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DelegatorVoteView_Opaque) 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 *DelegatorVoteView_Opaque) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegatorVoteView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DelegatorVote != nil { + { + size, err := m.DelegatorVote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DelegatorVotePlan) 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 *DelegatorVotePlan) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegatorVotePlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ProofBlindingS) > 0 { + i -= len(m.ProofBlindingS) + copy(dAtA[i:], m.ProofBlindingS) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ProofBlindingS))) + i-- + dAtA[i] = 0x4a + } + if len(m.ProofBlindingR) > 0 { + i -= len(m.ProofBlindingR) + copy(dAtA[i:], m.ProofBlindingR) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ProofBlindingR))) + i-- + dAtA[i] = 0x42 + } + if len(m.Randomizer) > 0 { + i -= len(m.Randomizer) + copy(dAtA[i:], m.Randomizer) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Randomizer))) + i-- + dAtA[i] = 0x3a + } + if m.UnbondedAmount != nil { + { + size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.StakedNotePosition != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.StakedNotePosition)) + i-- + dAtA[i] = 0x28 + } + if m.StakedNote != nil { + { + size, err := m.StakedNote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Vote != nil { + { + size, err := m.Vote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.StartPosition != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.StartPosition)) + i-- + dAtA[i] = 0x10 + } + if m.Proposal != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *CommunityPoolDeposit) 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 *CommunityPoolDeposit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommunityPoolDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CommunityPoolSpend) 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 *CommunityPoolSpend) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommunityPoolSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CommunityPoolOutput) 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 *CommunityPoolOutput) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommunityPoolOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Address != nil { + { + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Vote) 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 *Vote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Vote != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Vote)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ProposalState) 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 *ProposalState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.State != nil { + { + size := m.State.Size() + i -= size + if _, err := m.State.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *ProposalState_Voting_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalState_Voting_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Voting != nil { + { + size, err := m.Voting.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *ProposalState_Withdrawn_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalState_Withdrawn_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Withdrawn != nil { + { + size, err := m.Withdrawn.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *ProposalState_Finished_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalState_Finished_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Finished != nil { + { + size, err := m.Finished.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *ProposalState_Claimed_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalState_Claimed_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Claimed != nil { + { + size, err := m.Claimed.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *ProposalState_Voting) 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 *ProposalState_Voting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalState_Voting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *ProposalState_Withdrawn) 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 *ProposalState_Withdrawn) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalState_Withdrawn) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalState_Finished) 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 *ProposalState_Finished) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalState_Finished) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Outcome != nil { + { + size, err := m.Outcome.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalState_Claimed) 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 *ProposalState_Claimed) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalState_Claimed) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Outcome != nil { + { + size, err := m.Outcome.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalOutcome) 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 *ProposalOutcome) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalOutcome) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Outcome != nil { + { + size := m.Outcome.Size() + i -= size + if _, err := m.Outcome.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *ProposalOutcome_Passed_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalOutcome_Passed_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Passed != nil { + { + size, err := m.Passed.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *ProposalOutcome_Failed_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalOutcome_Failed_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Failed != nil { + { + size, err := m.Failed.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *ProposalOutcome_Slashed_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalOutcome_Slashed_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Slashed != nil { + { + size, err := m.Slashed.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *ProposalOutcome_Withdrawn) 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 *ProposalOutcome_Withdrawn) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalOutcome_Withdrawn) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalOutcome_Passed) 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 *ProposalOutcome_Passed) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalOutcome_Passed) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *ProposalOutcome_Failed) 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 *ProposalOutcome_Failed) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalOutcome_Failed) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Withdrawn != nil { + { + size, err := m.Withdrawn.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalOutcome_Slashed) 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 *ProposalOutcome_Slashed) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalOutcome_Slashed) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Withdrawn != nil { + { + size, err := m.Withdrawn.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Tally) 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 *Tally) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Tally) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Abstain != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Abstain)) + i-- + dAtA[i] = 0x18 + } + if m.No != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.No)) + i-- + dAtA[i] = 0x10 + } + if m.Yes != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Yes)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Proposal) 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 *Proposal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.UnfreezeIbcClient != nil { + { + size, err := m.UnfreezeIbcClient.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + } + if m.FreezeIbcClient != nil { + { + size, err := m.FreezeIbcClient.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if m.UpgradePlan != nil { + { + size, err := m.UpgradePlan.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if m.CommunityPoolSpend != nil { + { + size, err := m.CommunityPoolSpend.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.ParameterChange != nil { + { + size, err := m.ParameterChange.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.Emergency != nil { + { + size, err := m.Emergency.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.Signaling != nil { + { + size, err := m.Signaling.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.Id != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x20 + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x12 + } + if len(m.Title) > 0 { + i -= len(m.Title) + copy(dAtA[i:], m.Title) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Title))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Proposal_Signaling) 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 *Proposal_Signaling) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Proposal_Signaling) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Commit) > 0 { + i -= len(m.Commit) + copy(dAtA[i:], m.Commit) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Commit))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Proposal_Emergency) 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 *Proposal_Emergency) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Proposal_Emergency) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.HaltChain { + i-- + if m.HaltChain { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Proposal_ParameterChange) 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 *Proposal_ParameterChange) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Proposal_ParameterChange) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NewParameters != nil { + { + size, err := m.NewParameters.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.OldParameters != nil { + { + size, err := m.OldParameters.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Proposal_CommunityPoolSpend) 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 *Proposal_CommunityPoolSpend) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Proposal_CommunityPoolSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TransactionPlan != nil { + { + size, err := m.TransactionPlan.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *Proposal_UpgradePlan) 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 *Proposal_UpgradePlan) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Proposal_UpgradePlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Proposal_FreezeIbcClient) 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 *Proposal_FreezeIbcClient) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Proposal_FreezeIbcClient) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ClientId) > 0 { + i -= len(m.ClientId) + copy(dAtA[i:], m.ClientId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ClientId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Proposal_UnfreezeIbcClient) 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 *Proposal_UnfreezeIbcClient) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Proposal_UnfreezeIbcClient) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ClientId) > 0 { + i -= len(m.ClientId) + copy(dAtA[i:], m.ClientId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ClientId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalInfoRequest) 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 *ProposalInfoRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ProposalId != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.ProposalId)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalInfoResponse) 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 *ProposalInfoResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.StartPosition != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.StartPosition)) + i-- + dAtA[i] = 0x10 + } + if m.StartBlockHeight != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.StartBlockHeight)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ProposalDataRequest) 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 *ProposalDataRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalDataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ProposalId != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.ProposalId)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalDataResponse) 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 *ProposalDataResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ProposalDepositAmount != nil { + { + size, err := m.ProposalDepositAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.State != nil { + { + size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.StartPosition != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.StartPosition)) + i-- + dAtA[i] = 0x20 + } + if m.EndBlockHeight != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.EndBlockHeight)) + i-- + dAtA[i] = 0x18 + } + if m.StartBlockHeight != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.StartBlockHeight)) + i-- + dAtA[i] = 0x10 + } + if m.Proposal != nil { + { + size, err := m.Proposal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalRateDataRequest) 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 *ProposalRateDataRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalRateDataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ProposalId != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.ProposalId)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalRateDataResponse) 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 *ProposalRateDataResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalRateDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RateData != nil { + { + size, err := m.RateData.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalListRequest) 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 *ProposalListRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Inactive { + i-- + if m.Inactive { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposalListResponse) 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 *ProposalListResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProposalListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.State != nil { + { + size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.StartPosition != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.StartPosition)) + i-- + dAtA[i] = 0x20 + } + if m.EndBlockHeight != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.EndBlockHeight)) + i-- + dAtA[i] = 0x18 + } + if m.StartBlockHeight != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.StartBlockHeight)) + i-- + dAtA[i] = 0x10 + } + if m.Proposal != nil { + { + size, err := m.Proposal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorVotesRequest) 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 *ValidatorVotesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorVotesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ProposalId != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.ProposalId)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorVotesResponse) 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 *ValidatorVotesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorVotesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IdentityKey != nil { + { + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Vote != nil { + { + size, err := m.Vote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GovernanceParameters) 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 *GovernanceParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GovernanceParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ProposalSlashThreshold) > 0 { + i -= len(m.ProposalSlashThreshold) + copy(dAtA[i:], m.ProposalSlashThreshold) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ProposalSlashThreshold))) + i-- + dAtA[i] = 0x2a + } + if len(m.ProposalPassThreshold) > 0 { + i -= len(m.ProposalPassThreshold) + copy(dAtA[i:], m.ProposalPassThreshold) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ProposalPassThreshold))) + i-- + dAtA[i] = 0x22 + } + if len(m.ProposalValidQuorum) > 0 { + i -= len(m.ProposalValidQuorum) + copy(dAtA[i:], m.ProposalValidQuorum) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ProposalValidQuorum))) + i-- + dAtA[i] = 0x1a + } + if m.ProposalDepositAmount != nil { + { + size, err := m.ProposalDepositAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.ProposalVotingBlocks != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.ProposalVotingBlocks)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.GovernanceParams != nil { + { + size, err := m.GovernanceParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ChangedAppParameters) 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 *ChangedAppParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangedAppParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DistributionsParams != nil { + { + size, err := m.DistributionsParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.FeeParams != nil { + { + size, err := m.FeeParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.StakeParams != nil { + { + size, err := m.StakeParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.IbcParams != nil { + { + size, err := m.IbcParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.GovernanceParams != nil { + { + size, err := m.GovernanceParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.CommunityPoolParams != nil { + { + size, err := m.CommunityPoolParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.ChainParams != nil { + { + size, err := m.ChainParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ChangedAppParametersSet) 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 *ChangedAppParametersSet) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangedAppParametersSet) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.New != nil { + { + size, err := m.New.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Old != nil { + { + size, err := m.Old.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *VotingPowerAtProposalStartRequest) 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 *VotingPowerAtProposalStartRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VotingPowerAtProposalStartRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IdentityKey != nil { + { + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.ProposalId != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.ProposalId)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *VotingPowerAtProposalStartResponse) 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 *VotingPowerAtProposalStartResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VotingPowerAtProposalStartResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.VotingPower != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.VotingPower)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AllTalliedDelegatorVotesForProposalRequest) 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 *AllTalliedDelegatorVotesForProposalRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AllTalliedDelegatorVotesForProposalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ProposalId != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.ProposalId)) + i-- + dAtA[i] = 0x10 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AllTalliedDelegatorVotesForProposalResponse) 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 *AllTalliedDelegatorVotesForProposalResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AllTalliedDelegatorVotesForProposalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IdentityKey != nil { + { + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Tally != nil { + { + size, err := m.Tally.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *NextProposalIdRequest) 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 *NextProposalIdRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NextProposalIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *NextProposalIdResponse) 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 *NextProposalIdResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NextProposalIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NextProposalId != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.NextProposalId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintGovernance(dAtA []byte, offset int, v uint64) int { + offset -= sovGovernance(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ZKDelegatorVoteProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalSubmit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proposal != nil { + l = m.Proposal.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.DepositAmount != nil { + l = m.DepositAmount.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalWithdraw) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proposal != 0 { + n += 1 + sovGovernance(uint64(m.Proposal)) + } + l = len(m.Reason) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalDepositClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proposal != 0 { + n += 1 + sovGovernance(uint64(m.Proposal)) + } + if m.DepositAmount != nil { + l = m.DepositAmount.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Outcome != nil { + l = m.Outcome.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ValidatorVote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Body != nil { + l = m.Body.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.AuthSig != nil { + l = m.AuthSig.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ValidatorVoteReason) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Reason) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ValidatorVoteBody) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proposal != 0 { + n += 1 + sovGovernance(uint64(m.Proposal)) + } + if m.Vote != nil { + l = m.Vote.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.GovernanceKey != nil { + l = m.GovernanceKey.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Reason != nil { + l = m.Reason.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *DelegatorVote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Body != nil { + l = m.Body.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.AuthSig != nil { + l = m.AuthSig.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Proof != nil { + l = m.Proof.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *DelegatorVoteBody) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proposal != 0 { + n += 1 + sovGovernance(uint64(m.Proposal)) + } + if m.StartPosition != 0 { + n += 1 + sovGovernance(uint64(m.StartPosition)) + } + if m.Vote != nil { + l = m.Vote.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.UnbondedAmount != nil { + l = m.UnbondedAmount.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Nullifier != nil { + l = m.Nullifier.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Rk != nil { + l = m.Rk.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *DelegatorVoteView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DelegatorVote != nil { + n += m.DelegatorVote.Size() + } + return n +} + +func (m *DelegatorVoteView_Visible_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Visible != nil { + l = m.Visible.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} +func (m *DelegatorVoteView_Opaque_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Opaque != nil { + l = m.Opaque.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} +func (m *DelegatorVoteView_Visible) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DelegatorVote != nil { + l = m.DelegatorVote.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Note != nil { + l = m.Note.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *DelegatorVoteView_Opaque) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DelegatorVote != nil { + l = m.DelegatorVote.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *DelegatorVotePlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proposal != 0 { + n += 1 + sovGovernance(uint64(m.Proposal)) + } + if m.StartPosition != 0 { + n += 1 + sovGovernance(uint64(m.StartPosition)) + } + if m.Vote != nil { + l = m.Vote.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.StakedNote != nil { + l = m.StakedNote.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.StakedNotePosition != 0 { + n += 1 + sovGovernance(uint64(m.StakedNotePosition)) + } + if m.UnbondedAmount != nil { + l = m.UnbondedAmount.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + l = len(m.Randomizer) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + l = len(m.ProofBlindingR) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + l = len(m.ProofBlindingS) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *CommunityPoolDeposit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *CommunityPoolSpend) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *CommunityPoolOutput) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Address != nil { + l = m.Address.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *Vote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Vote != 0 { + n += 1 + sovGovernance(uint64(m.Vote)) + } + return n +} + +func (m *ProposalState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.State != nil { + n += m.State.Size() + } + return n +} + +func (m *ProposalState_Voting_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Voting != nil { + l = m.Voting.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} +func (m *ProposalState_Withdrawn_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Withdrawn != nil { + l = m.Withdrawn.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} +func (m *ProposalState_Finished_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Finished != nil { + l = m.Finished.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} +func (m *ProposalState_Claimed_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Claimed != nil { + l = m.Claimed.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} +func (m *ProposalState_Voting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *ProposalState_Withdrawn) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Reason) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalState_Finished) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Outcome != nil { + l = m.Outcome.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalState_Claimed) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Outcome != nil { + l = m.Outcome.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalOutcome) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Outcome != nil { + n += m.Outcome.Size() + } + return n +} + +func (m *ProposalOutcome_Passed_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Passed != nil { + l = m.Passed.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} +func (m *ProposalOutcome_Failed_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Failed != nil { + l = m.Failed.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} +func (m *ProposalOutcome_Slashed_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slashed != nil { + l = m.Slashed.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} +func (m *ProposalOutcome_Withdrawn) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Reason) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalOutcome_Passed) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *ProposalOutcome_Failed) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Withdrawn != nil { + l = m.Withdrawn.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalOutcome_Slashed) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Withdrawn != nil { + l = m.Withdrawn.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *Tally) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Yes != 0 { + n += 1 + sovGovernance(uint64(m.Yes)) + } + if m.No != 0 { + n += 1 + sovGovernance(uint64(m.No)) + } + if m.Abstain != 0 { + n += 1 + sovGovernance(uint64(m.Abstain)) + } + return n +} + +func (m *Proposal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Title) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Id != 0 { + n += 1 + sovGovernance(uint64(m.Id)) + } + if m.Signaling != nil { + l = m.Signaling.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Emergency != nil { + l = m.Emergency.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.ParameterChange != nil { + l = m.ParameterChange.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.CommunityPoolSpend != nil { + l = m.CommunityPoolSpend.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.UpgradePlan != nil { + l = m.UpgradePlan.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.FreezeIbcClient != nil { + l = m.FreezeIbcClient.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.UnfreezeIbcClient != nil { + l = m.UnfreezeIbcClient.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *Proposal_Signaling) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Commit) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *Proposal_Emergency) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.HaltChain { + n += 2 + } + return n +} + +func (m *Proposal_ParameterChange) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.OldParameters != nil { + l = m.OldParameters.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.NewParameters != nil { + l = m.NewParameters.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *Proposal_CommunityPoolSpend) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TransactionPlan != nil { + l = m.TransactionPlan.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *Proposal_UpgradePlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovGovernance(uint64(m.Height)) + } + return n +} + +func (m *Proposal_FreezeIbcClient) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClientId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *Proposal_UnfreezeIbcClient) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClientId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalInfoRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.ProposalId != 0 { + n += 1 + sovGovernance(uint64(m.ProposalId)) + } + return n +} + +func (m *ProposalInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StartBlockHeight != 0 { + n += 1 + sovGovernance(uint64(m.StartBlockHeight)) + } + if m.StartPosition != 0 { + n += 1 + sovGovernance(uint64(m.StartPosition)) + } + return n +} + +func (m *ProposalDataRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.ProposalId != 0 { + n += 1 + sovGovernance(uint64(m.ProposalId)) + } + return n +} + +func (m *ProposalDataResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proposal != nil { + l = m.Proposal.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.StartBlockHeight != 0 { + n += 1 + sovGovernance(uint64(m.StartBlockHeight)) + } + if m.EndBlockHeight != 0 { + n += 1 + sovGovernance(uint64(m.EndBlockHeight)) + } + if m.StartPosition != 0 { + n += 1 + sovGovernance(uint64(m.StartPosition)) + } + if m.State != nil { + l = m.State.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.ProposalDepositAmount != nil { + l = m.ProposalDepositAmount.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalRateDataRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.ProposalId != 0 { + n += 1 + sovGovernance(uint64(m.ProposalId)) + } + return n +} + +func (m *ProposalRateDataResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RateData != nil { + l = m.RateData.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ProposalListRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Inactive { + n += 2 + } + return n +} + +func (m *ProposalListResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proposal != nil { + l = m.Proposal.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.StartBlockHeight != 0 { + n += 1 + sovGovernance(uint64(m.StartBlockHeight)) + } + if m.EndBlockHeight != 0 { + n += 1 + sovGovernance(uint64(m.EndBlockHeight)) + } + if m.StartPosition != 0 { + n += 1 + sovGovernance(uint64(m.StartPosition)) + } + if m.State != nil { + l = m.State.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ValidatorVotesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.ProposalId != 0 { + n += 1 + sovGovernance(uint64(m.ProposalId)) + } + return n +} + +func (m *ValidatorVotesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Vote != nil { + l = m.Vote.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *GovernanceParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ProposalVotingBlocks != 0 { + n += 1 + sovGovernance(uint64(m.ProposalVotingBlocks)) + } + if m.ProposalDepositAmount != nil { + l = m.ProposalDepositAmount.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + l = len(m.ProposalValidQuorum) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + l = len(m.ProposalPassThreshold) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + l = len(m.ProposalSlashThreshold) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GovernanceParams != nil { + l = m.GovernanceParams.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ChangedAppParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ChainParams != nil { + l = m.ChainParams.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.CommunityPoolParams != nil { + l = m.CommunityPoolParams.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.GovernanceParams != nil { + l = m.GovernanceParams.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.IbcParams != nil { + l = m.IbcParams.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.StakeParams != nil { + l = m.StakeParams.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.FeeParams != nil { + l = m.FeeParams.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.DistributionsParams != nil { + l = m.DistributionsParams.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *ChangedAppParametersSet) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Old != nil { + l = m.Old.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.New != nil { + l = m.New.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *VotingPowerAtProposalStartRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.ProposalId != 0 { + n += 1 + sovGovernance(uint64(m.ProposalId)) + } + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *VotingPowerAtProposalStartResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.VotingPower != 0 { + n += 1 + sovGovernance(uint64(m.VotingPower)) + } + return n +} + +func (m *AllTalliedDelegatorVotesForProposalRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.ProposalId != 0 { + n += 1 + sovGovernance(uint64(m.ProposalId)) + } + return n +} + +func (m *AllTalliedDelegatorVotesForProposalResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Tally != nil { + l = m.Tally.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *NextProposalIdRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func (m *NextProposalIdResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NextProposalId != 0 { + n += 1 + sovGovernance(uint64(m.NextProposalId)) + } + return n +} + +func sovGovernance(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGovernance(x uint64) (n int) { + return sovGovernance(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ZKDelegatorVoteProof) 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 ErrIntOverflowGovernance + } + 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: ZKDelegatorVoteProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZKDelegatorVoteProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalSubmit) 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 ErrIntOverflowGovernance + } + 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: ProposalSubmit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalSubmit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proposal == nil { + m.Proposal = &Proposal{} + } + if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DepositAmount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DepositAmount == nil { + m.DepositAmount = &v1alpha1.Amount{} + } + if err := m.DepositAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalWithdraw) 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 ErrIntOverflowGovernance + } + 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: ProposalWithdraw: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalWithdraw: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) + } + m.Proposal = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Proposal |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalDepositClaim) 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 ErrIntOverflowGovernance + } + 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: ProposalDepositClaim: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalDepositClaim: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) + } + m.Proposal = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Proposal |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DepositAmount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DepositAmount == nil { + m.DepositAmount = &v1alpha1.Amount{} + } + if err := m.DepositAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Outcome", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Outcome == nil { + m.Outcome = &ProposalOutcome{} + } + if err := m.Outcome.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorVote) 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 ErrIntOverflowGovernance + } + 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: ValidatorVote: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorVote: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = &ValidatorVoteBody{} + } + if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthSig == nil { + m.AuthSig = &v1alpha11.SpendAuthSignature{} + } + if err := m.AuthSig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorVoteReason) 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 ErrIntOverflowGovernance + } + 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: ValidatorVoteReason: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorVoteReason: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorVoteBody) 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 ErrIntOverflowGovernance + } + 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: ValidatorVoteBody: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorVoteBody: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) + } + m.Proposal = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Proposal |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Vote == nil { + m.Vote = &Vote{} + } + if err := m.Vote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.IdentityKey == nil { + m.IdentityKey = &v1alpha12.IdentityKey{} + } + if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GovernanceKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GovernanceKey == nil { + m.GovernanceKey = &v1alpha12.GovernanceKey{} + } + if err := m.GovernanceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Reason == nil { + m.Reason = &ValidatorVoteReason{} + } + if err := m.Reason.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DelegatorVote) 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 ErrIntOverflowGovernance + } + 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: DelegatorVote: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DelegatorVote: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = &DelegatorVoteBody{} + } + if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthSig == nil { + m.AuthSig = &v1alpha11.SpendAuthSignature{} + } + if err := m.AuthSig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proof == nil { + m.Proof = &ZKDelegatorVoteProof{} + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DelegatorVoteBody) 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 ErrIntOverflowGovernance + } + 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: DelegatorVoteBody: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DelegatorVoteBody: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) + } + m.Proposal = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Proposal |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartPosition", wireType) + } + m.StartPosition = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartPosition |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Vote == nil { + m.Vote = &Vote{} + } + if err := m.Vote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &v1alpha13.Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.UnbondedAmount == nil { + m.UnbondedAmount = &v1alpha1.Amount{} + } + if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nullifier == nil { + m.Nullifier = &v1alpha14.Nullifier{} + } + if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rk", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Rk == nil { + m.Rk = &v1alpha11.SpendVerificationKey{} + } + if err := m.Rk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DelegatorVoteView) 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 ErrIntOverflowGovernance + } + 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: DelegatorVoteView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DelegatorVoteView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &DelegatorVoteView_Visible{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.DelegatorVote = &DelegatorVoteView_Visible_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &DelegatorVoteView_Opaque{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.DelegatorVote = &DelegatorVoteView_Opaque_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DelegatorVoteView_Visible) 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 ErrIntOverflowGovernance + } + 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: Visible: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DelegatorVote == nil { + m.DelegatorVote = &DelegatorVote{} + } + if err := m.DelegatorVote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Note == nil { + m.Note = &v1alpha15.NoteView{} + } + if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DelegatorVoteView_Opaque) 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 ErrIntOverflowGovernance + } + 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: Opaque: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DelegatorVote == nil { + m.DelegatorVote = &DelegatorVote{} + } + if err := m.DelegatorVote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DelegatorVotePlan) 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 ErrIntOverflowGovernance + } + 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: DelegatorVotePlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DelegatorVotePlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) + } + m.Proposal = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Proposal |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartPosition", wireType) + } + m.StartPosition = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartPosition |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Vote == nil { + m.Vote = &Vote{} + } + if err := m.Vote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StakedNote", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StakedNote == nil { + m.StakedNote = &v1alpha15.Note{} + } + if err := m.StakedNote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StakedNotePosition", wireType) + } + m.StakedNotePosition = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StakedNotePosition |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.UnbondedAmount == nil { + m.UnbondedAmount = &v1alpha1.Amount{} + } + if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Randomizer", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Randomizer = append(m.Randomizer[:0], dAtA[iNdEx:postIndex]...) + if m.Randomizer == nil { + m.Randomizer = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingR == nil { + m.ProofBlindingR = []byte{} + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingS == nil { + m.ProofBlindingS = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommunityPoolDeposit) 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 ErrIntOverflowGovernance + } + 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: CommunityPoolDeposit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommunityPoolDeposit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &v1alpha13.Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommunityPoolSpend) 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 ErrIntOverflowGovernance + } + 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: CommunityPoolSpend: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommunityPoolSpend: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &v1alpha13.Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommunityPoolOutput) 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 ErrIntOverflowGovernance + } + 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: CommunityPoolOutput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommunityPoolOutput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &v1alpha13.Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &v1alpha12.Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Vote) 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 ErrIntOverflowGovernance + } + 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: Vote: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Vote: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) + } + m.Vote = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Vote |= Vote_Vote(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalState) 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 ErrIntOverflowGovernance + } + 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: ProposalState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Voting", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ProposalState_Voting{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.State = &ProposalState_Voting_{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawn", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ProposalState_Withdrawn{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.State = &ProposalState_Withdrawn_{v} + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Finished", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ProposalState_Finished{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.State = &ProposalState_Finished_{v} + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Claimed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ProposalState_Claimed{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.State = &ProposalState_Claimed_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalState_Voting) 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 ErrIntOverflowGovernance + } + 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: Voting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Voting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalState_Withdrawn) 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 ErrIntOverflowGovernance + } + 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: Withdrawn: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Withdrawn: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalState_Finished) 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 ErrIntOverflowGovernance + } + 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: Finished: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Finished: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Outcome", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Outcome == nil { + m.Outcome = &ProposalOutcome{} + } + if err := m.Outcome.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalState_Claimed) 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 ErrIntOverflowGovernance + } + 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: Claimed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Claimed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Outcome", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Outcome == nil { + m.Outcome = &ProposalOutcome{} + } + if err := m.Outcome.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalOutcome) 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 ErrIntOverflowGovernance + } + 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: ProposalOutcome: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalOutcome: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Passed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ProposalOutcome_Passed{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Outcome = &ProposalOutcome_Passed_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ProposalOutcome_Failed{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Outcome = &ProposalOutcome_Failed_{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slashed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ProposalOutcome_Slashed{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Outcome = &ProposalOutcome_Slashed_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalOutcome_Withdrawn) 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 ErrIntOverflowGovernance + } + 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: Withdrawn: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Withdrawn: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalOutcome_Passed) 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 ErrIntOverflowGovernance + } + 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: Passed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Passed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalOutcome_Failed) 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 ErrIntOverflowGovernance + } + 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: Failed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Failed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawn", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Withdrawn == nil { + m.Withdrawn = &ProposalOutcome_Withdrawn{} + } + if err := m.Withdrawn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalOutcome_Slashed) 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 ErrIntOverflowGovernance + } + 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: Slashed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Slashed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawn", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Withdrawn == nil { + m.Withdrawn = &ProposalOutcome_Withdrawn{} + } + if err := m.Withdrawn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Tally) 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 ErrIntOverflowGovernance + } + 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: Tally: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Tally: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Yes", wireType) + } + m.Yes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Yes |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field No", wireType) + } + m.No = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.No |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Abstain", wireType) + } + m.Abstain = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Abstain |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Proposal) 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 ErrIntOverflowGovernance + } + 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: Proposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Proposal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signaling", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Signaling == nil { + m.Signaling = &Proposal_Signaling{} + } + if err := m.Signaling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Emergency", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Emergency == nil { + m.Emergency = &Proposal_Emergency{} + } + if err := m.Emergency.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParameterChange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ParameterChange == nil { + m.ParameterChange = &Proposal_ParameterChange{} + } + if err := m.ParameterChange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolSpend", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CommunityPoolSpend == nil { + m.CommunityPoolSpend = &Proposal_CommunityPoolSpend{} + } + if err := m.CommunityPoolSpend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UpgradePlan", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.UpgradePlan == nil { + m.UpgradePlan = &Proposal_UpgradePlan{} + } + if err := m.UpgradePlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FreezeIbcClient", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FreezeIbcClient == nil { + m.FreezeIbcClient = &Proposal_FreezeIbcClient{} + } + if err := m.FreezeIbcClient.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnfreezeIbcClient", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.UnfreezeIbcClient == nil { + m.UnfreezeIbcClient = &Proposal_UnfreezeIbcClient{} + } + if err := m.UnfreezeIbcClient.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Proposal_Signaling) 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 ErrIntOverflowGovernance + } + 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: Signaling: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Signaling: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Commit = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Proposal_Emergency) 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 ErrIntOverflowGovernance + } + 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: Emergency: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Emergency: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HaltChain", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.HaltChain = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Proposal_ParameterChange) 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 ErrIntOverflowGovernance + } + 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: ParameterChange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ParameterChange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OldParameters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.OldParameters == nil { + m.OldParameters = &ChangedAppParameters{} + } + if err := m.OldParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewParameters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NewParameters == nil { + m.NewParameters = &ChangedAppParameters{} + } + if err := m.NewParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Proposal_CommunityPoolSpend) 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 ErrIntOverflowGovernance + } + 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: CommunityPoolSpend: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommunityPoolSpend: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionPlan", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TransactionPlan == nil { + m.TransactionPlan = &types.Any{} + } + if err := m.TransactionPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Proposal_UpgradePlan) 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 ErrIntOverflowGovernance + } + 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: UpgradePlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpgradePlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Proposal_FreezeIbcClient) 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 ErrIntOverflowGovernance + } + 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: FreezeIbcClient: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FreezeIbcClient: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Proposal_UnfreezeIbcClient) 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 ErrIntOverflowGovernance + } + 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: UnfreezeIbcClient: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnfreezeIbcClient: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalInfoRequest) 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 ErrIntOverflowGovernance + } + 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: ProposalInfoRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + m.ProposalId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalInfoResponse) 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 ErrIntOverflowGovernance + } + 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: ProposalInfoResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBlockHeight", wireType) + } + m.StartBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartPosition", wireType) + } + m.StartPosition = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartPosition |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalDataRequest) 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 ErrIntOverflowGovernance + } + 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: ProposalDataRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalDataRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + m.ProposalId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalDataResponse) 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 ErrIntOverflowGovernance + } + 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: ProposalDataResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalDataResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proposal == nil { + m.Proposal = &Proposal{} + } + if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBlockHeight", wireType) + } + m.StartBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndBlockHeight", wireType) + } + m.EndBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartPosition", wireType) + } + m.StartPosition = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartPosition |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.State == nil { + m.State = &ProposalState{} + } + if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositAmount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposalDepositAmount == nil { + m.ProposalDepositAmount = &v1alpha1.Amount{} + } + if err := m.ProposalDepositAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalRateDataRequest) 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 ErrIntOverflowGovernance + } + 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: ProposalRateDataRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalRateDataRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + m.ProposalId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalRateDataResponse) 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 ErrIntOverflowGovernance + } + 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: ProposalRateDataResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalRateDataResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RateData == nil { + m.RateData = &v1alpha16.RateData{} + } + if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalListRequest) 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 ErrIntOverflowGovernance + } + 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: ProposalListRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalListRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Inactive", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Inactive = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposalListResponse) 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 ErrIntOverflowGovernance + } + 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: ProposalListResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposalListResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proposal == nil { + m.Proposal = &Proposal{} + } + if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBlockHeight", wireType) + } + m.StartBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndBlockHeight", wireType) + } + m.EndBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartPosition", wireType) + } + m.StartPosition = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartPosition |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.State == nil { + m.State = &ProposalState{} + } + if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorVotesRequest) 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 ErrIntOverflowGovernance + } + 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: ValidatorVotesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorVotesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + m.ProposalId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorVotesResponse) 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 ErrIntOverflowGovernance + } + 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: ValidatorVotesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorVotesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Vote == nil { + m.Vote = &Vote{} + } + if err := m.Vote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.IdentityKey == nil { + m.IdentityKey = &v1alpha12.IdentityKey{} + } + if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GovernanceParameters) 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 ErrIntOverflowGovernance + } + 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: GovernanceParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GovernanceParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalVotingBlocks", wireType) + } + m.ProposalVotingBlocks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposalVotingBlocks |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositAmount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposalDepositAmount == nil { + m.ProposalDepositAmount = &v1alpha1.Amount{} + } + if err := m.ProposalDepositAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalValidQuorum", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProposalValidQuorum = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalPassThreshold", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProposalPassThreshold = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalSlashThreshold", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProposalSlashThreshold = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent) 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 ErrIntOverflowGovernance + } + 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: GenesisContent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GovernanceParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GovernanceParams == nil { + m.GovernanceParams = &GovernanceParameters{} + } + if err := m.GovernanceParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ChangedAppParameters) 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 ErrIntOverflowGovernance + } + 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: ChangedAppParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ChangedAppParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChainParams == nil { + m.ChainParams = &v1alpha17.ChainParameters{} + } + if err := m.ChainParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CommunityPoolParams == nil { + m.CommunityPoolParams = &v1alpha18.CommunityPoolParameters{} + } + if err := m.CommunityPoolParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GovernanceParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GovernanceParams == nil { + m.GovernanceParams = &GovernanceParameters{} + } + if err := m.GovernanceParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IbcParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.IbcParams == nil { + m.IbcParams = &v1alpha19.IbcParameters{} + } + if err := m.IbcParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StakeParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StakeParams == nil { + m.StakeParams = &v1alpha16.StakeParameters{} + } + if err := m.StakeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FeeParams == nil { + m.FeeParams = &v1alpha110.FeeParameters{} + } + if err := m.FeeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DistributionsParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DistributionsParams == nil { + m.DistributionsParams = &v1alpha111.DistributionsParameters{} + } + if err := m.DistributionsParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ChangedAppParametersSet) 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 ErrIntOverflowGovernance + } + 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: ChangedAppParametersSet: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ChangedAppParametersSet: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Old", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Old == nil { + m.Old = &ChangedAppParameters{} + } + if err := m.Old.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field New", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.New == nil { + m.New = &ChangedAppParameters{} + } + if err := m.New.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *VotingPowerAtProposalStartRequest) 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 ErrIntOverflowGovernance + } + 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: VotingPowerAtProposalStartRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VotingPowerAtProposalStartRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + m.ProposalId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.IdentityKey == nil { + m.IdentityKey = &v1alpha12.IdentityKey{} + } + if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *VotingPowerAtProposalStartResponse) 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 ErrIntOverflowGovernance + } + 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: VotingPowerAtProposalStartResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VotingPowerAtProposalStartResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType) + } + m.VotingPower = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VotingPower |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllTalliedDelegatorVotesForProposalRequest) 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 ErrIntOverflowGovernance + } + 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: AllTalliedDelegatorVotesForProposalRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllTalliedDelegatorVotesForProposalRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + m.ProposalId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllTalliedDelegatorVotesForProposalResponse) 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 ErrIntOverflowGovernance + } + 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: AllTalliedDelegatorVotesForProposalResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllTalliedDelegatorVotesForProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tally", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Tally == nil { + m.Tally = &Tally{} + } + if err := m.Tally.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.IdentityKey == nil { + m.IdentityKey = &v1alpha12.IdentityKey{} + } + if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NextProposalIdRequest) 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 ErrIntOverflowGovernance + } + 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: NextProposalIdRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NextProposalIdRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NextProposalIdResponse) 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 ErrIntOverflowGovernance + } + 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: NextProposalIdResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NextProposalIdResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NextProposalId", wireType) + } + m.NextProposalId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NextProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGovernance(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, ErrIntOverflowGovernance + } + 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, ErrIntOverflowGovernance + } + 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, ErrIntOverflowGovernance + } + 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, ErrInvalidLengthGovernance + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGovernance + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGovernance + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGovernance = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGovernance = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGovernance = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/ibc/v1alpha1/ibc.pb.go b/relayer/chains/penumbra/core/component/ibc/v1alpha1/ibc.pb.go similarity index 71% rename from relayer/chains/penumbra/core/ibc/v1alpha1/ibc.pb.go rename to relayer/chains/penumbra/core/component/ibc/v1alpha1/ibc.pb.go index 8bf6ff767..e55dcbcf9 100644 --- a/relayer/chains/penumbra/core/ibc/v1alpha1/ibc.pb.go +++ b/relayer/chains/penumbra/core/component/ibc/v1alpha1/ibc.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: penumbra/core/ibc/v1alpha1/ibc.proto +// source: penumbra/core/component/ibc/v1alpha1/ibc.proto package ibcv1alpha1 @@ -7,8 +7,10 @@ import ( fmt "fmt" types "github.com/cosmos/cosmos-sdk/codec/types" proto "github.com/cosmos/gogoproto/proto" - types1 "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" + types1 "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" io "io" math "math" math_bits "math/bits" @@ -25,45 +27,22 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package -type IbcAction struct { - // - // oneof action { - // .ibc.core.connection.v1.MsgConnectionOpenInit connection_open_init = 1; - // .ibc.core.connection.v1.MsgConnectionOpenTry connection_open_try = 2; - // .ibc.core.connection.v1.MsgConnectionOpenAck connection_open_ack = 3; - // .ibc.core.connection.v1.MsgConnectionOpenConfirm connection_open_confirm = 4; - // - // .ibc.core.channel.v1.MsgChannelOpenInit channel_open_init = 5; - // .ibc.core.channel.v1.MsgChannelOpenTry channel_open_try = 6; - // .ibc.core.channel.v1.MsgChannelOpenAck channel_open_ack = 7; - // .ibc.core.channel.v1.MsgChannelOpenConfirm channel_open_confirm = 8; - // .ibc.core.channel.v1.MsgChannelCloseInit channel_close_init = 9; - // .ibc.core.channel.v1.MsgChannelCloseConfirm channel_close_confirm = 10; - // - // .ibc.core.channel.v1.MsgRecvPacket recv_packet = 11; - // .ibc.core.channel.v1.MsgTimeout timeout = 12; - // .ibc.core.channel.v1.MsgAcknowledgement acknowledgement = 13; - // - // .ibc.core.client.v1.MsgCreateClient create_client = 14; - // .ibc.core.client.v1.MsgUpdateClient update_client = 15; - // .ibc.core.client.v1.MsgUpgradeClient upgrade_client = 16; - // .ibc.core.client.v1.MsgSubmitMisbehaviour submit_misbehaviour = 17; - // } +type IbcRelay struct { RawAction *types.Any `protobuf:"bytes,1,opt,name=raw_action,json=rawAction,proto3" json:"raw_action,omitempty"` } -func (m *IbcAction) Reset() { *m = IbcAction{} } -func (m *IbcAction) String() string { return proto.CompactTextString(m) } -func (*IbcAction) ProtoMessage() {} -func (*IbcAction) Descriptor() ([]byte, []int) { - return fileDescriptor_6509740287584c65, []int{0} +func (m *IbcRelay) Reset() { *m = IbcRelay{} } +func (m *IbcRelay) String() string { return proto.CompactTextString(m) } +func (*IbcRelay) ProtoMessage() {} +func (*IbcRelay) Descriptor() ([]byte, []int) { + return fileDescriptor_86476aff0cbfadc3, []int{0} } -func (m *IbcAction) XXX_Unmarshal(b []byte) error { +func (m *IbcRelay) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *IbcAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *IbcRelay) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_IbcAction.Marshal(b, m, deterministic) + return xxx_messageInfo_IbcRelay.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -73,19 +52,19 @@ func (m *IbcAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *IbcAction) XXX_Merge(src proto.Message) { - xxx_messageInfo_IbcAction.Merge(m, src) +func (m *IbcRelay) XXX_Merge(src proto.Message) { + xxx_messageInfo_IbcRelay.Merge(m, src) } -func (m *IbcAction) XXX_Size() int { +func (m *IbcRelay) XXX_Size() int { return m.Size() } -func (m *IbcAction) XXX_DiscardUnknown() { - xxx_messageInfo_IbcAction.DiscardUnknown(m) +func (m *IbcRelay) XXX_DiscardUnknown() { + xxx_messageInfo_IbcRelay.DiscardUnknown(m) } -var xxx_messageInfo_IbcAction proto.InternalMessageInfo +var xxx_messageInfo_IbcRelay proto.InternalMessageInfo -func (m *IbcAction) GetRawAction() *types.Any { +func (m *IbcRelay) GetRawAction() *types.Any { if m != nil { return m.RawAction } @@ -100,7 +79,7 @@ type FungibleTokenPacketData struct { Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` // the token amount to be transferred Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` - // the sender address + // the return address Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"` // the recipient address on the destination chain Receiver string `protobuf:"bytes,4,opt,name=receiver,proto3" json:"receiver,omitempty"` @@ -110,7 +89,7 @@ func (m *FungibleTokenPacketData) Reset() { *m = FungibleTokenPacketData func (m *FungibleTokenPacketData) String() string { return proto.CompactTextString(m) } func (*FungibleTokenPacketData) ProtoMessage() {} func (*FungibleTokenPacketData) Descriptor() ([]byte, []int) { - return fileDescriptor_6509740287584c65, []int{1} + return fileDescriptor_86476aff0cbfadc3, []int{1} } func (m *FungibleTokenPacketData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -167,20 +146,18 @@ func (m *FungibleTokenPacketData) GetReceiver() string { return "" } +// A Penumbra transaction action requesting an ICS20 transfer. type Ics20Withdrawal struct { Amount *v1alpha1.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` - Denom *v1alpha1.Denom `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"` + Denom *v1alpha11.Denom `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"` // the address on the destination chain to send the transfer to DestinationChainAddress string `protobuf:"bytes,3,opt,name=destination_chain_address,json=destinationChainAddress,proto3" json:"destination_chain_address,omitempty"` // a "sender" penumbra address to use to return funds from this withdrawal. // this should be an ephemeral address - ReturnAddress *v1alpha1.Address `protobuf:"bytes,4,opt,name=return_address,json=returnAddress,proto3" json:"return_address,omitempty"` - // the height (on Penumbra) at which this transfer expires (and funds are sent - // back to the sender address?). NOTE: if funds are sent back to the sender, - // we MUST verify a nonexistence proof before accepting the timeout, to - // prevent relayer censorship attacks. The core IBC implementation does this - // in its handling of validation of timeouts. - TimeoutHeight uint64 `protobuf:"varint,5,opt,name=timeout_height,json=timeoutHeight,proto3" json:"timeout_height,omitempty"` + ReturnAddress *v1alpha12.Address `protobuf:"bytes,4,opt,name=return_address,json=returnAddress,proto3" json:"return_address,omitempty"` + // The height on the counterparty chain at which this transfer expires, and + // funds are sent back to the return address. + TimeoutHeight *types1.Height `protobuf:"bytes,5,opt,name=timeout_height,json=timeoutHeight,proto3" json:"timeout_height,omitempty"` // the timestamp at which this transfer expires. TimeoutTime uint64 `protobuf:"varint,6,opt,name=timeout_time,json=timeoutTime,proto3" json:"timeout_time,omitempty"` // the source channel used for the withdrawal @@ -191,7 +168,7 @@ func (m *Ics20Withdrawal) Reset() { *m = Ics20Withdrawal{} } func (m *Ics20Withdrawal) String() string { return proto.CompactTextString(m) } func (*Ics20Withdrawal) ProtoMessage() {} func (*Ics20Withdrawal) Descriptor() ([]byte, []int) { - return fileDescriptor_6509740287584c65, []int{2} + return fileDescriptor_86476aff0cbfadc3, []int{2} } func (m *Ics20Withdrawal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -227,7 +204,7 @@ func (m *Ics20Withdrawal) GetAmount() *v1alpha1.Amount { return nil } -func (m *Ics20Withdrawal) GetDenom() *v1alpha1.Denom { +func (m *Ics20Withdrawal) GetDenom() *v1alpha11.Denom { if m != nil { return m.Denom } @@ -241,18 +218,18 @@ func (m *Ics20Withdrawal) GetDestinationChainAddress() string { return "" } -func (m *Ics20Withdrawal) GetReturnAddress() *v1alpha1.Address { +func (m *Ics20Withdrawal) GetReturnAddress() *v1alpha12.Address { if m != nil { return m.ReturnAddress } return nil } -func (m *Ics20Withdrawal) GetTimeoutHeight() uint64 { +func (m *Ics20Withdrawal) GetTimeoutHeight() *types1.Height { if m != nil { return m.TimeoutHeight } - return 0 + return nil } func (m *Ics20Withdrawal) GetTimeoutTime() uint64 { @@ -280,7 +257,7 @@ func (m *ClientData) Reset() { *m = ClientData{} } func (m *ClientData) String() string { return proto.CompactTextString(m) } func (*ClientData) ProtoMessage() {} func (*ClientData) Descriptor() ([]byte, []int) { - return fileDescriptor_6509740287584c65, []int{3} + return fileDescriptor_86476aff0cbfadc3, []int{3} } func (m *ClientData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -345,7 +322,7 @@ func (m *ClientCounter) Reset() { *m = ClientCounter{} } func (m *ClientCounter) String() string { return proto.CompactTextString(m) } func (*ClientCounter) ProtoMessage() {} func (*ClientCounter) Descriptor() ([]byte, []int) { - return fileDescriptor_6509740287584c65, []int{4} + return fileDescriptor_86476aff0cbfadc3, []int{4} } func (m *ClientCounter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -389,7 +366,7 @@ func (m *ConsensusState) Reset() { *m = ConsensusState{} } func (m *ConsensusState) String() string { return proto.CompactTextString(m) } func (*ConsensusState) ProtoMessage() {} func (*ConsensusState) Descriptor() ([]byte, []int) { - return fileDescriptor_6509740287584c65, []int{5} + return fileDescriptor_86476aff0cbfadc3, []int{5} } func (m *ConsensusState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -433,7 +410,7 @@ func (m *VerifiedHeights) Reset() { *m = VerifiedHeights{} } func (m *VerifiedHeights) String() string { return proto.CompactTextString(m) } func (*VerifiedHeights) ProtoMessage() {} func (*VerifiedHeights) Descriptor() ([]byte, []int) { - return fileDescriptor_6509740287584c65, []int{6} + return fileDescriptor_86476aff0cbfadc3, []int{6} } func (m *VerifiedHeights) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -477,7 +454,7 @@ func (m *ConnectionCounter) Reset() { *m = ConnectionCounter{} } func (m *ConnectionCounter) String() string { return proto.CompactTextString(m) } func (*ConnectionCounter) ProtoMessage() {} func (*ConnectionCounter) Descriptor() ([]byte, []int) { - return fileDescriptor_6509740287584c65, []int{7} + return fileDescriptor_86476aff0cbfadc3, []int{7} } func (m *ConnectionCounter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -521,7 +498,7 @@ func (m *ClientConnections) Reset() { *m = ClientConnections{} } func (m *ClientConnections) String() string { return proto.CompactTextString(m) } func (*ClientConnections) ProtoMessage() {} func (*ClientConnections) Descriptor() ([]byte, []int) { - return fileDescriptor_6509740287584c65, []int{8} + return fileDescriptor_86476aff0cbfadc3, []int{8} } func (m *ClientConnections) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -557,76 +534,198 @@ func (m *ClientConnections) GetConnections() []string { return nil } +// IBC configuration data. +type IbcParameters struct { + // Whether IBC (forming connections, processing IBC packets) is enabled. + IbcEnabled bool `protobuf:"varint,1,opt,name=ibc_enabled,json=ibcEnabled,proto3" json:"ibc_enabled,omitempty"` + // Whether inbound ICS-20 transfers are enabled + InboundIcs20TransfersEnabled bool `protobuf:"varint,2,opt,name=inbound_ics20_transfers_enabled,json=inboundIcs20TransfersEnabled,proto3" json:"inbound_ics20_transfers_enabled,omitempty"` + // Whether outbound ICS-20 transfers are enabled + OutboundIcs20TransfersEnabled bool `protobuf:"varint,3,opt,name=outbound_ics20_transfers_enabled,json=outboundIcs20TransfersEnabled,proto3" json:"outbound_ics20_transfers_enabled,omitempty"` +} + +func (m *IbcParameters) Reset() { *m = IbcParameters{} } +func (m *IbcParameters) String() string { return proto.CompactTextString(m) } +func (*IbcParameters) ProtoMessage() {} +func (*IbcParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_86476aff0cbfadc3, []int{9} +} +func (m *IbcParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *IbcParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_IbcParameters.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 *IbcParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_IbcParameters.Merge(m, src) +} +func (m *IbcParameters) XXX_Size() int { + return m.Size() +} +func (m *IbcParameters) XXX_DiscardUnknown() { + xxx_messageInfo_IbcParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_IbcParameters proto.InternalMessageInfo + +func (m *IbcParameters) GetIbcEnabled() bool { + if m != nil { + return m.IbcEnabled + } + return false +} + +func (m *IbcParameters) GetInboundIcs20TransfersEnabled() bool { + if m != nil { + return m.InboundIcs20TransfersEnabled + } + return false +} + +func (m *IbcParameters) GetOutboundIcs20TransfersEnabled() bool { + if m != nil { + return m.OutboundIcs20TransfersEnabled + } + return false +} + +// IBC genesis state. +type GenesisContent struct { + // IBC parameters. + IbcParams *IbcParameters `protobuf:"bytes,1,opt,name=ibc_params,json=ibcParams,proto3" json:"ibc_params,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_86476aff0cbfadc3, []int{10} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.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 *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetIbcParams() *IbcParameters { + if m != nil { + return m.IbcParams + } + return nil +} + func init() { - proto.RegisterType((*IbcAction)(nil), "penumbra.core.ibc.v1alpha1.IbcAction") - proto.RegisterType((*FungibleTokenPacketData)(nil), "penumbra.core.ibc.v1alpha1.FungibleTokenPacketData") - proto.RegisterType((*Ics20Withdrawal)(nil), "penumbra.core.ibc.v1alpha1.Ics20Withdrawal") - proto.RegisterType((*ClientData)(nil), "penumbra.core.ibc.v1alpha1.ClientData") - proto.RegisterType((*ClientCounter)(nil), "penumbra.core.ibc.v1alpha1.ClientCounter") - proto.RegisterType((*ConsensusState)(nil), "penumbra.core.ibc.v1alpha1.ConsensusState") - proto.RegisterType((*VerifiedHeights)(nil), "penumbra.core.ibc.v1alpha1.VerifiedHeights") - proto.RegisterType((*ConnectionCounter)(nil), "penumbra.core.ibc.v1alpha1.ConnectionCounter") - proto.RegisterType((*ClientConnections)(nil), "penumbra.core.ibc.v1alpha1.ClientConnections") + proto.RegisterType((*IbcRelay)(nil), "penumbra.core.component.ibc.v1alpha1.IbcRelay") + proto.RegisterType((*FungibleTokenPacketData)(nil), "penumbra.core.component.ibc.v1alpha1.FungibleTokenPacketData") + proto.RegisterType((*Ics20Withdrawal)(nil), "penumbra.core.component.ibc.v1alpha1.Ics20Withdrawal") + proto.RegisterType((*ClientData)(nil), "penumbra.core.component.ibc.v1alpha1.ClientData") + proto.RegisterType((*ClientCounter)(nil), "penumbra.core.component.ibc.v1alpha1.ClientCounter") + proto.RegisterType((*ConsensusState)(nil), "penumbra.core.component.ibc.v1alpha1.ConsensusState") + proto.RegisterType((*VerifiedHeights)(nil), "penumbra.core.component.ibc.v1alpha1.VerifiedHeights") + proto.RegisterType((*ConnectionCounter)(nil), "penumbra.core.component.ibc.v1alpha1.ConnectionCounter") + proto.RegisterType((*ClientConnections)(nil), "penumbra.core.component.ibc.v1alpha1.ClientConnections") + proto.RegisterType((*IbcParameters)(nil), "penumbra.core.component.ibc.v1alpha1.IbcParameters") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.ibc.v1alpha1.GenesisContent") } func init() { - proto.RegisterFile("penumbra/core/ibc/v1alpha1/ibc.proto", fileDescriptor_6509740287584c65) -} - -var fileDescriptor_6509740287584c65 = []byte{ - // 773 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x54, 0x41, 0x8f, 0x1b, 0x35, - 0x14, 0xde, 0x49, 0xd2, 0xdd, 0x8d, 0xd3, 0x24, 0x74, 0x54, 0xd1, 0x69, 0x10, 0x21, 0x8c, 0xda, - 0x6a, 0x8b, 0xc4, 0x0c, 0x49, 0x41, 0x48, 0x83, 0x2a, 0x91, 0x9d, 0x8a, 0x32, 0x87, 0x8a, 0x68, - 0xa8, 0x8a, 0x84, 0x22, 0x45, 0x1e, 0x8f, 0x9b, 0x58, 0x9b, 0xb1, 0x23, 0xdb, 0x93, 0x55, 0xc4, - 0x1f, 0xe0, 0xc8, 0x5f, 0x80, 0x23, 0x67, 0x7e, 0x04, 0xe2, 0xb4, 0x47, 0x8e, 0x28, 0x7b, 0xe3, - 0x57, 0x20, 0xdb, 0xe3, 0x64, 0x57, 0x62, 0xbb, 0xa7, 0xf8, 0x7d, 0xef, 0x7b, 0x2f, 0xdf, 0xf7, - 0xde, 0xd8, 0xe0, 0xd1, 0x0a, 0xd3, 0xb2, 0xc8, 0x38, 0x0c, 0x11, 0xe3, 0x38, 0x24, 0x19, 0x0a, - 0xd7, 0x43, 0xb8, 0x5c, 0x2d, 0xe0, 0x50, 0x05, 0xc1, 0x8a, 0x33, 0xc9, 0xdc, 0x9e, 0x65, 0x05, - 0x8a, 0x15, 0xa8, 0x84, 0x65, 0xf5, 0x3e, 0xb9, 0xde, 0x01, 0xf1, 0xcd, 0x4a, 0xb2, 0x7d, 0x13, - 0x13, 0x9b, 0x3e, 0xbd, 0x8f, 0x54, 0x7f, 0x43, 0x5b, 0x12, 0x4c, 0x65, 0xb8, 0x1e, 0x56, 0xa7, - 0x8a, 0xf0, 0x70, 0xce, 0xd8, 0x7c, 0x89, 0x43, 0x1d, 0x65, 0xe5, 0xdb, 0x10, 0xd2, 0x8d, 0x49, - 0xf9, 0x5f, 0x83, 0x66, 0x92, 0xa1, 0x31, 0x92, 0x84, 0x51, 0xf7, 0x19, 0x00, 0x1c, 0x9e, 0xcf, - 0xa0, 0x8e, 0x3c, 0x67, 0xe0, 0x9c, 0xb4, 0x46, 0xf7, 0x03, 0x53, 0x1c, 0xd8, 0xe2, 0x60, 0x4c, - 0x37, 0x69, 0x93, 0xc3, 0x73, 0x53, 0xe4, 0xff, 0x04, 0x1e, 0x7c, 0x53, 0xd2, 0x39, 0xc9, 0x96, - 0xf8, 0x35, 0x3b, 0xc3, 0x74, 0x02, 0xd1, 0x19, 0x96, 0x2f, 0xa0, 0x84, 0xee, 0x7d, 0x70, 0x27, - 0xc7, 0x94, 0x15, 0xba, 0x55, 0x33, 0x35, 0x81, 0xfb, 0x3e, 0x38, 0x84, 0x05, 0x2b, 0xa9, 0xf4, - 0x6a, 0x1a, 0xae, 0x22, 0x85, 0x0b, 0x4c, 0x73, 0xcc, 0xbd, 0xba, 0xc1, 0x4d, 0xe4, 0xf6, 0xc0, - 0x31, 0xc7, 0x08, 0x93, 0x35, 0xe6, 0x5e, 0x43, 0x67, 0x76, 0xb1, 0xff, 0x73, 0x1d, 0x74, 0x13, - 0x24, 0x46, 0x9f, 0xfd, 0x40, 0xe4, 0x22, 0xe7, 0xf0, 0x1c, 0x2e, 0xdd, 0xe7, 0xbb, 0xfe, 0xc6, - 0xc1, 0xe3, 0xe0, 0xfa, 0x9c, 0xab, 0xd9, 0xd9, 0x59, 0x06, 0x63, 0x4d, 0xde, 0xc9, 0x88, 0xac, - 0xe8, 0x9a, 0xae, 0x7e, 0x74, 0x4b, 0xf5, 0x0b, 0xc5, 0xb5, 0xd6, 0x22, 0xf0, 0x30, 0xc7, 0x42, - 0x12, 0x0a, 0xd5, 0x68, 0x66, 0x68, 0x01, 0x09, 0x9d, 0xc1, 0x3c, 0xe7, 0x58, 0x88, 0xca, 0xd5, - 0x83, 0x2b, 0x84, 0x58, 0xe5, 0xc7, 0x26, 0xed, 0xbe, 0x02, 0x1d, 0x8e, 0x65, 0xc9, 0xf7, 0x05, - 0x0d, 0x2d, 0xe0, 0xc9, 0x6d, 0xf2, 0x0d, 0x3b, 0x6d, 0x9b, 0x6a, 0xdb, 0xee, 0x31, 0xe8, 0x48, - 0x52, 0x60, 0x56, 0xca, 0xd9, 0x02, 0x93, 0xf9, 0x42, 0x7a, 0x77, 0x06, 0xce, 0x49, 0x23, 0x6d, - 0x57, 0xe8, 0xb7, 0x1a, 0x74, 0x3f, 0x06, 0x77, 0x2d, 0x4d, 0xfd, 0x7a, 0x87, 0x9a, 0xd4, 0xaa, - 0xb0, 0xd7, 0xa4, 0xc0, 0xaa, 0x93, 0x60, 0x25, 0x47, 0x58, 0xf9, 0xa1, 0x14, 0x2f, 0xbd, 0x23, - 0xed, 0xa4, 0x6d, 0xd0, 0xd8, 0x80, 0xfe, 0x1f, 0x0e, 0x00, 0xb1, 0xfe, 0xea, 0xf4, 0xee, 0x3f, - 0x00, 0x4d, 0xf3, 0x0d, 0xce, 0x48, 0x5e, 0xed, 0xff, 0xd8, 0x00, 0x49, 0xee, 0x7e, 0x09, 0xee, - 0x56, 0x49, 0x21, 0xa1, 0xc4, 0xd5, 0xa8, 0xff, 0xff, 0x53, 0x6b, 0x19, 0xe6, 0xf7, 0x8a, 0xa8, - 0xb4, 0xac, 0x38, 0x43, 0x58, 0x08, 0x9c, 0x1b, 0xc1, 0x66, 0xaa, 0xed, 0x1d, 0xaa, 0x25, 0x3f, - 0x05, 0xef, 0xed, 0x69, 0x95, 0xfd, 0x86, 0x76, 0xd6, 0xdd, 0xe1, 0x66, 0x00, 0xfe, 0x53, 0xd0, - 0x36, 0xaa, 0x63, 0xb5, 0x7d, 0xcc, 0x5d, 0x0f, 0x1c, 0x21, 0x73, 0xd4, 0xb2, 0x1b, 0xa9, 0x0d, - 0xfd, 0xef, 0x40, 0x27, 0x66, 0x54, 0x60, 0x2a, 0x4a, 0x61, 0xe4, 0x3c, 0x07, 0x5d, 0x64, 0x91, - 0xca, 0xca, 0xbb, 0x6e, 0x4d, 0x07, 0x5d, 0x2b, 0xf7, 0x5f, 0x82, 0xee, 0x1b, 0xcc, 0xc9, 0x5b, - 0x62, 0xd5, 0x08, 0xf7, 0x73, 0x70, 0x64, 0xf4, 0x0a, 0xcf, 0x19, 0xd4, 0x4f, 0x5a, 0xa3, 0x9e, - 0x7e, 0x17, 0xcc, 0xe6, 0xcd, 0x9d, 0x5e, 0x0f, 0x03, 0xc3, 0x4e, 0x2d, 0xd5, 0xff, 0x14, 0xdc, - 0x8b, 0x19, 0xa5, 0x58, 0xdf, 0xc8, 0xdb, 0x8d, 0x7c, 0x01, 0xee, 0x59, 0xcf, 0xb6, 0x48, 0xb8, - 0x03, 0xd0, 0x42, 0xfb, 0x50, 0xff, 0x7b, 0x33, 0xbd, 0x0a, 0x9d, 0xfe, 0x5a, 0xfb, 0x73, 0xdb, - 0x77, 0x2e, 0xb6, 0x7d, 0xe7, 0x9f, 0x6d, 0xdf, 0xf9, 0xe5, 0xb2, 0x7f, 0x70, 0x71, 0xd9, 0x3f, - 0xf8, 0xfb, 0xb2, 0x7f, 0x00, 0xfa, 0x88, 0x15, 0xc1, 0xcd, 0xcf, 0xd9, 0xe9, 0x71, 0x92, 0xa1, - 0x89, 0x1a, 0xc5, 0xc4, 0xf9, 0x31, 0x9d, 0x13, 0xb9, 0x28, 0xb3, 0x00, 0xb1, 0x22, 0x44, 0x4c, - 0x14, 0x4c, 0x84, 0x1c, 0x2f, 0xe1, 0x06, 0xf3, 0x70, 0x3d, 0xda, 0x1d, 0xf5, 0xdd, 0x11, 0xe1, - 0xcd, 0x0f, 0xe9, 0x57, 0x24, 0x43, 0xf6, 0xfc, 0x5b, 0xad, 0x3e, 0x89, 0x93, 0xdf, 0x6b, 0xbd, - 0x89, 0x95, 0x10, 0x2b, 0x09, 0x49, 0x86, 0x82, 0x37, 0x15, 0xe5, 0xaf, 0x7d, 0x72, 0xaa, 0x92, - 0xd3, 0x24, 0x43, 0x53, 0x9b, 0xdc, 0xd6, 0x9e, 0xdc, 0x9c, 0x9c, 0xbe, 0x9c, 0x9c, 0xbe, 0xc2, - 0x12, 0xe6, 0x50, 0xc2, 0x7f, 0x6b, 0x1f, 0x5a, 0x62, 0x14, 0x29, 0x66, 0x14, 0x25, 0x19, 0x8a, - 0x22, 0xcb, 0xcd, 0x0e, 0xf5, 0xc2, 0x9f, 0xfd, 0x17, 0x00, 0x00, 0xff, 0xff, 0x1b, 0x2a, 0x21, - 0xe0, 0x02, 0x06, 0x00, 0x00, -} - -func (m *IbcAction) Marshal() (dAtA []byte, err error) { + proto.RegisterFile("penumbra/core/component/ibc/v1alpha1/ibc.proto", fileDescriptor_86476aff0cbfadc3) +} + +var fileDescriptor_86476aff0cbfadc3 = []byte{ + // 941 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x95, 0x4f, 0x6f, 0x1b, 0xc5, + 0x1b, 0xc7, 0xb3, 0x8e, 0x9b, 0x3f, 0x93, 0xda, 0xf9, 0x75, 0x55, 0xfd, 0xea, 0x06, 0x70, 0xcc, + 0x12, 0x90, 0x7b, 0x60, 0xb7, 0x49, 0x40, 0x08, 0x23, 0x84, 0x9c, 0x6d, 0x09, 0x16, 0x42, 0x58, + 0x4b, 0x54, 0x24, 0x64, 0xc9, 0x9a, 0x9d, 0x7d, 0x62, 0x8f, 0xe2, 0x9d, 0xb1, 0x66, 0x66, 0x1d, + 0x45, 0xbc, 0x09, 0x5e, 0x01, 0x07, 0x8e, 0x9c, 0x79, 0x01, 0x1c, 0x11, 0xa7, 0x1e, 0xb9, 0x81, + 0x92, 0x1b, 0xaf, 0x02, 0xcd, 0xcc, 0xce, 0xba, 0xae, 0xaa, 0x36, 0x97, 0x64, 0x9f, 0x67, 0x3f, + 0xdf, 0x67, 0xbe, 0xcf, 0xcc, 0x33, 0x6b, 0x14, 0xce, 0x81, 0x15, 0x79, 0x2a, 0x70, 0x44, 0xb8, + 0x80, 0x88, 0xf0, 0x7c, 0xce, 0x19, 0x30, 0x15, 0xd1, 0x94, 0x44, 0x8b, 0x43, 0x3c, 0x9b, 0x4f, + 0xf1, 0xa1, 0x0e, 0xc2, 0xb9, 0xe0, 0x8a, 0xfb, 0x07, 0x8e, 0x0f, 0x35, 0x1f, 0x56, 0x7c, 0xa8, + 0x11, 0xc7, 0xef, 0x3d, 0x9c, 0x70, 0x3e, 0x99, 0x41, 0x64, 0x34, 0x69, 0x71, 0x1e, 0x61, 0x76, + 0x65, 0x0b, 0xec, 0xed, 0xeb, 0xc2, 0x76, 0xad, 0x19, 0xd5, 0x0b, 0x2d, 0x0e, 0xcb, 0xa7, 0x12, + 0xe8, 0xae, 0x3a, 0xc2, 0x52, 0x82, 0x5a, 0x3a, 0x31, 0x61, 0x49, 0x7e, 0xb0, 0x4a, 0x5e, 0xc0, + 0x95, 0x5c, 0x82, 0x3a, 0x2a, 0xb9, 0x83, 0x55, 0x8e, 0x15, 0xf9, 0x12, 0x63, 0x45, 0x6e, 0xa9, + 0xe0, 0x0b, 0xb4, 0x35, 0x48, 0x49, 0x02, 0x33, 0x7c, 0xe5, 0x1f, 0x23, 0x24, 0xf0, 0xe5, 0x18, + 0x13, 0x45, 0x39, 0x6b, 0x79, 0x1d, 0xaf, 0xbb, 0x73, 0x74, 0x3f, 0xb4, 0x4d, 0x85, 0xae, 0xa9, + 0xb0, 0xcf, 0xae, 0x92, 0x6d, 0x81, 0x2f, 0xfb, 0x06, 0x0b, 0x7e, 0x44, 0x0f, 0xbe, 0x2c, 0xd8, + 0x84, 0xa6, 0x33, 0x38, 0xe3, 0x17, 0xc0, 0x86, 0x98, 0x5c, 0x80, 0x7a, 0x82, 0x15, 0xf6, 0xef, + 0xa3, 0x3b, 0x19, 0x30, 0x9e, 0x9b, 0x52, 0xdb, 0x89, 0x0d, 0xfc, 0xff, 0xa3, 0x0d, 0x9c, 0xf3, + 0x82, 0xa9, 0x56, 0xcd, 0xa4, 0xcb, 0x48, 0xe7, 0x25, 0xb0, 0x0c, 0x44, 0x6b, 0xdd, 0xe6, 0x6d, + 0xe4, 0xef, 0xa1, 0x2d, 0x01, 0x04, 0xe8, 0x02, 0x44, 0xab, 0x6e, 0xde, 0x54, 0x71, 0xf0, 0xf3, + 0x3a, 0xda, 0x1d, 0x10, 0x79, 0xf4, 0xf8, 0x7b, 0xaa, 0xa6, 0x99, 0xc0, 0x97, 0x78, 0xe6, 0xf7, + 0xaa, 0xfa, 0xb6, 0x83, 0x20, 0x5c, 0x3d, 0x3c, 0xdd, 0xbb, 0xdb, 0x88, 0xb0, 0x6f, 0xc8, 0xca, + 0xc3, 0xa7, 0xce, 0x71, 0xcd, 0x48, 0xdf, 0x7b, 0x49, 0x6a, 0x8f, 0xa1, 0x12, 0x3f, 0xd1, 0xa8, + 0x6b, 0xab, 0x87, 0x1e, 0x66, 0x20, 0x15, 0x65, 0x58, 0x6f, 0xcb, 0x98, 0x4c, 0x31, 0x65, 0x63, + 0x9c, 0x65, 0x02, 0xa4, 0x2c, 0x3b, 0x7a, 0xf0, 0x02, 0x10, 0xeb, 0xf7, 0x7d, 0xfb, 0xda, 0xff, + 0x1a, 0x35, 0x05, 0xa8, 0x42, 0x2c, 0x05, 0x75, 0xb3, 0xfe, 0xc1, 0x4b, 0xeb, 0x9b, 0xd3, 0x5d, + 0x7a, 0xb7, 0x6c, 0xd2, 0xb0, 0x5a, 0x57, 0xac, 0x8f, 0x9a, 0x8a, 0xe6, 0xc0, 0x0b, 0x35, 0x9e, + 0x02, 0x9d, 0x4c, 0x55, 0xeb, 0x8e, 0x29, 0xb6, 0x67, 0x86, 0xd5, 0xce, 0xaf, 0x9d, 0xbc, 0xc5, + 0x61, 0xf8, 0x95, 0x21, 0x92, 0x46, 0xa9, 0xb0, 0xa1, 0xff, 0x2e, 0xba, 0xeb, 0x4a, 0xe8, 0xff, + 0xad, 0x8d, 0x8e, 0xd7, 0xad, 0x27, 0x3b, 0x65, 0xee, 0x8c, 0xe6, 0xe0, 0xbf, 0x8f, 0x9a, 0x92, + 0x17, 0x82, 0x80, 0xee, 0x94, 0x31, 0x98, 0xb5, 0x36, 0x4d, 0x8f, 0x0d, 0x9b, 0x8d, 0x6d, 0x32, + 0xf8, 0xcd, 0x43, 0x28, 0x36, 0xab, 0x99, 0x89, 0x78, 0x0b, 0x6d, 0xdb, 0xb5, 0xc7, 0x34, 0x2b, + 0xa7, 0x62, 0xcb, 0x26, 0x06, 0x99, 0xff, 0x09, 0xba, 0x5b, 0xbe, 0x94, 0x0a, 0x2b, 0x28, 0xcf, + 0xe0, 0xd5, 0x03, 0xb8, 0x63, 0xc9, 0xef, 0x34, 0xa8, 0xbd, 0xcc, 0x05, 0x27, 0x20, 0x25, 0x64, + 0xd6, 0xb0, 0xdd, 0xef, 0x46, 0x95, 0x35, 0x96, 0x1f, 0xa1, 0xff, 0x2d, 0xb1, 0x72, 0x6b, 0xea, + 0xa6, 0xb3, 0xdd, 0x2a, 0x6f, 0x37, 0x20, 0x78, 0x84, 0x1a, 0xd6, 0x75, 0xac, 0xc7, 0x02, 0x84, + 0xdf, 0x42, 0x9b, 0xc4, 0x3e, 0x1a, 0xdb, 0xf5, 0xc4, 0x85, 0xc1, 0xb7, 0xa8, 0x19, 0x73, 0x26, + 0x81, 0xc9, 0x42, 0x5a, 0x3b, 0x9f, 0xa3, 0x5d, 0xe2, 0x32, 0x65, 0x2b, 0xaf, 0xbb, 0x4b, 0x4d, + 0xb2, 0x22, 0x0f, 0x4e, 0xd1, 0xee, 0x33, 0x10, 0xf4, 0x9c, 0x3a, 0x37, 0xd2, 0xff, 0x08, 0x6d, + 0x5a, 0xbf, 0xb2, 0xe5, 0x75, 0xd6, 0xdf, 0x70, 0x96, 0x0e, 0x0d, 0x3e, 0x44, 0xf7, 0x62, 0xce, + 0x18, 0x98, 0x7b, 0xfa, 0xe6, 0x46, 0x3e, 0x46, 0xf7, 0x5c, 0xcf, 0x4e, 0x24, 0xfd, 0x0e, 0xda, + 0x21, 0xcb, 0xd0, 0xac, 0xbe, 0x9d, 0xbc, 0x98, 0x0a, 0x7e, 0xf7, 0x50, 0x63, 0x90, 0x92, 0x21, + 0x16, 0x38, 0x07, 0x05, 0x42, 0xfa, 0xfb, 0x68, 0x87, 0xa6, 0x64, 0x0c, 0x0c, 0xa7, 0x33, 0xb0, + 0xc7, 0xbc, 0x95, 0x20, 0x9a, 0x92, 0xa7, 0x36, 0xe3, 0x3f, 0x45, 0xfb, 0x94, 0xa5, 0xbc, 0x60, + 0xd9, 0x98, 0xea, 0xcb, 0x3b, 0x56, 0x02, 0x33, 0x79, 0x0e, 0x42, 0x56, 0xa2, 0x9a, 0x11, 0xbd, + 0x5d, 0x62, 0xe6, 0x8a, 0x9f, 0x39, 0xc8, 0x95, 0x39, 0x45, 0x1d, 0x5e, 0xa8, 0xd7, 0xd7, 0x59, + 0x37, 0x75, 0xde, 0x71, 0xdc, 0x2b, 0x0b, 0x05, 0x19, 0x6a, 0x9e, 0x02, 0x03, 0x49, 0x65, 0xcc, + 0x99, 0x02, 0xa6, 0xfc, 0x04, 0x69, 0xbf, 0xe3, 0xb9, 0x6e, 0x4a, 0x96, 0xa7, 0x77, 0x1c, 0xde, + 0xe6, 0x47, 0x20, 0x5c, 0xd9, 0x8b, 0x64, 0x9b, 0x96, 0xa1, 0x3c, 0xf9, 0xbb, 0xf6, 0xc7, 0x75, + 0xdb, 0x7b, 0x7e, 0xdd, 0xf6, 0xfe, 0xb9, 0x6e, 0x7b, 0x3f, 0xdd, 0xb4, 0xd7, 0x9e, 0xdf, 0xb4, + 0xd7, 0xfe, 0xba, 0x69, 0xaf, 0xa1, 0x2e, 0xe1, 0xf9, 0xad, 0xaa, 0x9f, 0xe8, 0x8f, 0xf5, 0x50, + 0x4f, 0xcf, 0xd0, 0xfb, 0x61, 0x34, 0xa1, 0x6a, 0x5a, 0xa4, 0x1a, 0x8d, 0x08, 0x97, 0x39, 0x97, + 0x91, 0xd0, 0xdf, 0x71, 0x10, 0xd1, 0xe2, 0xa8, 0x7a, 0x34, 0x1f, 0x22, 0x19, 0xdd, 0xe6, 0x07, + 0xef, 0x33, 0x9a, 0x12, 0xf7, 0xfc, 0x4b, 0xad, 0x3e, 0x8c, 0xe3, 0xc1, 0xaf, 0xb5, 0x83, 0xa1, + 0xf3, 0x15, 0x6b, 0x5f, 0x71, 0xe5, 0x6b, 0x90, 0x92, 0xf0, 0x59, 0x49, 0xff, 0xb9, 0xc4, 0x46, + 0x1a, 0x1b, 0x55, 0xd8, 0x68, 0x90, 0x92, 0x91, 0xc3, 0xae, 0x6b, 0x8f, 0x6f, 0x83, 0x8d, 0x4e, + 0x87, 0x27, 0xdf, 0x80, 0xc2, 0x19, 0x56, 0xf8, 0xdf, 0x5a, 0xd7, 0x49, 0x7a, 0x3d, 0xad, 0xd1, + 0x7f, 0x4b, 0x51, 0xaf, 0x37, 0x48, 0x49, 0xaf, 0xe7, 0x64, 0xe9, 0x86, 0xb9, 0x57, 0xc7, 0xff, + 0x05, 0x00, 0x00, 0xff, 0xff, 0x47, 0x09, 0x81, 0x16, 0xde, 0x07, 0x00, 0x00, +} + +func (m *IbcRelay) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -636,12 +735,12 @@ func (m *IbcAction) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *IbcAction) MarshalTo(dAtA []byte) (int, error) { +func (m *IbcRelay) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *IbcAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *IbcRelay) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -744,10 +843,17 @@ func (m *Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x30 } - if m.TimeoutHeight != 0 { - i = encodeVarintIbc(dAtA, i, uint64(m.TimeoutHeight)) + if m.TimeoutHeight != nil { + { + size, err := m.TimeoutHeight.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintIbc(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x28 + dAtA[i] = 0x2a } if m.ReturnAddress != nil { { @@ -1009,6 +1115,94 @@ func (m *ClientConnections) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *IbcParameters) 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 *IbcParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *IbcParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.OutboundIcs20TransfersEnabled { + i-- + if m.OutboundIcs20TransfersEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.InboundIcs20TransfersEnabled { + i-- + if m.InboundIcs20TransfersEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.IbcEnabled { + i-- + if m.IbcEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IbcParams != nil { + { + size, err := m.IbcParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintIbc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintIbc(dAtA []byte, offset int, v uint64) int { offset -= sovIbc(v) base := offset @@ -1020,7 +1214,7 @@ func encodeVarintIbc(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } -func (m *IbcAction) Size() (n int) { +func (m *IbcRelay) Size() (n int) { if m == nil { return 0 } @@ -1080,8 +1274,9 @@ func (m *Ics20Withdrawal) Size() (n int) { l = m.ReturnAddress.Size() n += 1 + l + sovIbc(uint64(l)) } - if m.TimeoutHeight != 0 { - n += 1 + sovIbc(uint64(m.TimeoutHeight)) + if m.TimeoutHeight != nil { + l = m.TimeoutHeight.Size() + n += 1 + l + sovIbc(uint64(l)) } if m.TimeoutTime != 0 { n += 1 + sovIbc(uint64(m.TimeoutTime)) @@ -1184,13 +1379,44 @@ func (m *ClientConnections) Size() (n int) { return n } +func (m *IbcParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IbcEnabled { + n += 2 + } + if m.InboundIcs20TransfersEnabled { + n += 2 + } + if m.OutboundIcs20TransfersEnabled { + n += 2 + } + return n +} + +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IbcParams != nil { + l = m.IbcParams.Size() + n += 1 + l + sovIbc(uint64(l)) + } + return n +} + func sovIbc(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozIbc(x uint64) (n int) { return sovIbc(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } -func (m *IbcAction) Unmarshal(dAtA []byte) error { +func (m *IbcRelay) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1213,10 +1439,10 @@ func (m *IbcAction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: IbcAction: wiretype end group for non-group") + return fmt.Errorf("proto: IbcRelay: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: IbcAction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IbcRelay: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -1549,7 +1775,7 @@ func (m *Ics20Withdrawal) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Denom == nil { - m.Denom = &v1alpha1.Denom{} + m.Denom = &v1alpha11.Denom{} } if err := m.Denom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -1617,17 +1843,17 @@ func (m *Ics20Withdrawal) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.ReturnAddress == nil { - m.ReturnAddress = &v1alpha1.Address{} + m.ReturnAddress = &v1alpha12.Address{} } if err := m.ReturnAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: - if wireType != 0 { + if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TimeoutHeight", wireType) } - m.TimeoutHeight = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIbc @@ -1637,11 +1863,28 @@ func (m *Ics20Withdrawal) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TimeoutHeight |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthIbc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthIbc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TimeoutHeight == nil { + m.TimeoutHeight = &types1.Height{} + } + if err := m.TimeoutHeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TimeoutTime", wireType) @@ -2273,6 +2516,202 @@ func (m *ClientConnections) Unmarshal(dAtA []byte) error { } return nil } +func (m *IbcParameters) 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 ErrIntOverflowIbc + } + 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: IbcParameters: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IbcParameters: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IbcEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIbc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IbcEnabled = bool(v != 0) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InboundIcs20TransfersEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIbc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.InboundIcs20TransfersEnabled = bool(v != 0) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OutboundIcs20TransfersEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIbc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.OutboundIcs20TransfersEnabled = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipIbc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthIbc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent) 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 ErrIntOverflowIbc + } + 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: GenesisContent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IbcParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIbc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthIbc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthIbc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.IbcParams == nil { + m.IbcParams = &IbcParameters{} + } + if err := m.IbcParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipIbc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthIbc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipIbc(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/relayer/chains/penumbra/core/component/sct/v1alpha1/sct.pb.go b/relayer/chains/penumbra/core/component/sct/v1alpha1/sct.pb.go new file mode 100644 index 000000000..fe6b47efa --- /dev/null +++ b/relayer/chains/penumbra/core/component/sct/v1alpha1/sct.pb.go @@ -0,0 +1,2939 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/sct/v1alpha1/sct.proto + +package sctv1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1alpha1" + grpc "google.golang.org/grpc" + 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 + +// Metadata describing the source of a commitment in the state commitment tree. +// +// This message allows clients to track provenance of state commitments, and to +// decide whether or not to download block data. +type CommitmentSource struct { + // Types that are valid to be assigned to Source: + // *CommitmentSource_Transaction_ + // *CommitmentSource_Ics_20Transfer + // *CommitmentSource_FundingStreamReward_ + // *CommitmentSource_CommunityPoolOutput_ + // *CommitmentSource_Genesis_ + Source isCommitmentSource_Source `protobuf_oneof:"source"` +} + +func (m *CommitmentSource) Reset() { *m = CommitmentSource{} } +func (m *CommitmentSource) String() string { return proto.CompactTextString(m) } +func (*CommitmentSource) ProtoMessage() {} +func (*CommitmentSource) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{0} +} +func (m *CommitmentSource) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitmentSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitmentSource.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 *CommitmentSource) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitmentSource.Merge(m, src) +} +func (m *CommitmentSource) XXX_Size() int { + return m.Size() +} +func (m *CommitmentSource) XXX_DiscardUnknown() { + xxx_messageInfo_CommitmentSource.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitmentSource proto.InternalMessageInfo + +type isCommitmentSource_Source interface { + isCommitmentSource_Source() + MarshalTo([]byte) (int, error) + Size() int +} + +type CommitmentSource_Transaction_ struct { + Transaction *CommitmentSource_Transaction `protobuf:"bytes,1,opt,name=transaction,proto3,oneof" json:"transaction,omitempty"` +} +type CommitmentSource_Ics_20Transfer struct { + Ics_20Transfer *CommitmentSource_Ics20Transfer `protobuf:"bytes,2,opt,name=ics_20_transfer,json=ics20Transfer,proto3,oneof" json:"ics_20_transfer,omitempty"` +} +type CommitmentSource_FundingStreamReward_ struct { + FundingStreamReward *CommitmentSource_FundingStreamReward `protobuf:"bytes,20,opt,name=funding_stream_reward,json=fundingStreamReward,proto3,oneof" json:"funding_stream_reward,omitempty"` +} +type CommitmentSource_CommunityPoolOutput_ struct { + CommunityPoolOutput *CommitmentSource_CommunityPoolOutput `protobuf:"bytes,30,opt,name=community_pool_output,json=communityPoolOutput,proto3,oneof" json:"community_pool_output,omitempty"` +} +type CommitmentSource_Genesis_ struct { + Genesis *CommitmentSource_Genesis `protobuf:"bytes,40,opt,name=genesis,proto3,oneof" json:"genesis,omitempty"` +} + +func (*CommitmentSource_Transaction_) isCommitmentSource_Source() {} +func (*CommitmentSource_Ics_20Transfer) isCommitmentSource_Source() {} +func (*CommitmentSource_FundingStreamReward_) isCommitmentSource_Source() {} +func (*CommitmentSource_CommunityPoolOutput_) isCommitmentSource_Source() {} +func (*CommitmentSource_Genesis_) isCommitmentSource_Source() {} + +func (m *CommitmentSource) GetSource() isCommitmentSource_Source { + if m != nil { + return m.Source + } + return nil +} + +func (m *CommitmentSource) GetTransaction() *CommitmentSource_Transaction { + if x, ok := m.GetSource().(*CommitmentSource_Transaction_); ok { + return x.Transaction + } + return nil +} + +func (m *CommitmentSource) GetIcs_20Transfer() *CommitmentSource_Ics20Transfer { + if x, ok := m.GetSource().(*CommitmentSource_Ics_20Transfer); ok { + return x.Ics_20Transfer + } + return nil +} + +func (m *CommitmentSource) GetFundingStreamReward() *CommitmentSource_FundingStreamReward { + if x, ok := m.GetSource().(*CommitmentSource_FundingStreamReward_); ok { + return x.FundingStreamReward + } + return nil +} + +func (m *CommitmentSource) GetCommunityPoolOutput() *CommitmentSource_CommunityPoolOutput { + if x, ok := m.GetSource().(*CommitmentSource_CommunityPoolOutput_); ok { + return x.CommunityPoolOutput + } + return nil +} + +func (m *CommitmentSource) GetGenesis() *CommitmentSource_Genesis { + if x, ok := m.GetSource().(*CommitmentSource_Genesis_); ok { + return x.Genesis + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*CommitmentSource) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*CommitmentSource_Transaction_)(nil), + (*CommitmentSource_Ics_20Transfer)(nil), + (*CommitmentSource_FundingStreamReward_)(nil), + (*CommitmentSource_CommunityPoolOutput_)(nil), + (*CommitmentSource_Genesis_)(nil), + } +} + +// The state commitment was included in the genesis state. +type CommitmentSource_Genesis struct { +} + +func (m *CommitmentSource_Genesis) Reset() { *m = CommitmentSource_Genesis{} } +func (m *CommitmentSource_Genesis) String() string { return proto.CompactTextString(m) } +func (*CommitmentSource_Genesis) ProtoMessage() {} +func (*CommitmentSource_Genesis) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{0, 0} +} +func (m *CommitmentSource_Genesis) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitmentSource_Genesis) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitmentSource_Genesis.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 *CommitmentSource_Genesis) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitmentSource_Genesis.Merge(m, src) +} +func (m *CommitmentSource_Genesis) XXX_Size() int { + return m.Size() +} +func (m *CommitmentSource_Genesis) XXX_DiscardUnknown() { + xxx_messageInfo_CommitmentSource_Genesis.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitmentSource_Genesis proto.InternalMessageInfo + +// The commitment was created by a transaction. +// +// When included in a `CompactBlock` via a `StatePayload`, the transaction source is "dehydrated" +// by stripping the `id` field and putting empty bytes in its place. When clients perform extended +// transaction fetch, they should match up transaction hashes to "rehydrate" the source info. +type CommitmentSource_Transaction struct { + // The transaction ID, if specified. + // + // This field may be omitted to save space, and should not be required to be present. + // If the bytes are missing, the message should be interpreted as "Transaction (Unknown)". + Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *CommitmentSource_Transaction) Reset() { *m = CommitmentSource_Transaction{} } +func (m *CommitmentSource_Transaction) String() string { return proto.CompactTextString(m) } +func (*CommitmentSource_Transaction) ProtoMessage() {} +func (*CommitmentSource_Transaction) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{0, 1} +} +func (m *CommitmentSource_Transaction) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitmentSource_Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitmentSource_Transaction.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 *CommitmentSource_Transaction) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitmentSource_Transaction.Merge(m, src) +} +func (m *CommitmentSource_Transaction) XXX_Size() int { + return m.Size() +} +func (m *CommitmentSource_Transaction) XXX_DiscardUnknown() { + xxx_messageInfo_CommitmentSource_Transaction.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitmentSource_Transaction proto.InternalMessageInfo + +func (m *CommitmentSource_Transaction) GetId() []byte { + if m != nil { + return m.Id + } + return nil +} + +// The commitment was created through a validator's funding stream. +type CommitmentSource_FundingStreamReward struct { + // The epoch index the rewards were issued in. + EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"` +} + +func (m *CommitmentSource_FundingStreamReward) Reset() { *m = CommitmentSource_FundingStreamReward{} } +func (m *CommitmentSource_FundingStreamReward) String() string { return proto.CompactTextString(m) } +func (*CommitmentSource_FundingStreamReward) ProtoMessage() {} +func (*CommitmentSource_FundingStreamReward) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{0, 2} +} +func (m *CommitmentSource_FundingStreamReward) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitmentSource_FundingStreamReward) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitmentSource_FundingStreamReward.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 *CommitmentSource_FundingStreamReward) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitmentSource_FundingStreamReward.Merge(m, src) +} +func (m *CommitmentSource_FundingStreamReward) XXX_Size() int { + return m.Size() +} +func (m *CommitmentSource_FundingStreamReward) XXX_DiscardUnknown() { + xxx_messageInfo_CommitmentSource_FundingStreamReward.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitmentSource_FundingStreamReward proto.InternalMessageInfo + +func (m *CommitmentSource_FundingStreamReward) GetEpochIndex() uint64 { + if m != nil { + return m.EpochIndex + } + return 0 +} + +// The commitment was created through a `CommunityPoolOutput` in a governance-initated transaction. +type CommitmentSource_CommunityPoolOutput struct { +} + +func (m *CommitmentSource_CommunityPoolOutput) Reset() { *m = CommitmentSource_CommunityPoolOutput{} } +func (m *CommitmentSource_CommunityPoolOutput) String() string { return proto.CompactTextString(m) } +func (*CommitmentSource_CommunityPoolOutput) ProtoMessage() {} +func (*CommitmentSource_CommunityPoolOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{0, 3} +} +func (m *CommitmentSource_CommunityPoolOutput) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitmentSource_CommunityPoolOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitmentSource_CommunityPoolOutput.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 *CommitmentSource_CommunityPoolOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitmentSource_CommunityPoolOutput.Merge(m, src) +} +func (m *CommitmentSource_CommunityPoolOutput) XXX_Size() int { + return m.Size() +} +func (m *CommitmentSource_CommunityPoolOutput) XXX_DiscardUnknown() { + xxx_messageInfo_CommitmentSource_CommunityPoolOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitmentSource_CommunityPoolOutput proto.InternalMessageInfo + +// The commitment was created by an inbound ICS20 transfer. +type CommitmentSource_Ics20Transfer struct { + // The sequence number of the packet that triggered the transfer + PacketSeq uint64 `protobuf:"varint,1,opt,name=packet_seq,json=packetSeq,proto3" json:"packet_seq,omitempty"` + // The channel id the transfer happened on + ChannelId string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"` + // The sender address on the counterparty chain + Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"` +} + +func (m *CommitmentSource_Ics20Transfer) Reset() { *m = CommitmentSource_Ics20Transfer{} } +func (m *CommitmentSource_Ics20Transfer) String() string { return proto.CompactTextString(m) } +func (*CommitmentSource_Ics20Transfer) ProtoMessage() {} +func (*CommitmentSource_Ics20Transfer) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{0, 4} +} +func (m *CommitmentSource_Ics20Transfer) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitmentSource_Ics20Transfer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitmentSource_Ics20Transfer.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 *CommitmentSource_Ics20Transfer) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitmentSource_Ics20Transfer.Merge(m, src) +} +func (m *CommitmentSource_Ics20Transfer) XXX_Size() int { + return m.Size() +} +func (m *CommitmentSource_Ics20Transfer) XXX_DiscardUnknown() { + xxx_messageInfo_CommitmentSource_Ics20Transfer.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitmentSource_Ics20Transfer proto.InternalMessageInfo + +func (m *CommitmentSource_Ics20Transfer) GetPacketSeq() uint64 { + if m != nil { + return m.PacketSeq + } + return 0 +} + +func (m *CommitmentSource_Ics20Transfer) GetChannelId() string { + if m != nil { + return m.ChannelId + } + return "" +} + +func (m *CommitmentSource_Ics20Transfer) GetSender() string { + if m != nil { + return m.Sender + } + return "" +} + +type Nullifier struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *Nullifier) Reset() { *m = Nullifier{} } +func (m *Nullifier) String() string { return proto.CompactTextString(m) } +func (*Nullifier) ProtoMessage() {} +func (*Nullifier) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{1} +} +func (m *Nullifier) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Nullifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Nullifier.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 *Nullifier) XXX_Merge(src proto.Message) { + xxx_messageInfo_Nullifier.Merge(m, src) +} +func (m *Nullifier) XXX_Size() int { + return m.Size() +} +func (m *Nullifier) XXX_DiscardUnknown() { + xxx_messageInfo_Nullifier.DiscardUnknown(m) +} + +var xxx_messageInfo_Nullifier proto.InternalMessageInfo + +func (m *Nullifier) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// Records information about what transaction spent a nullifier. +type NullificationInfo struct { + Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + SpendHeight uint64 `protobuf:"varint,2,opt,name=spend_height,json=spendHeight,proto3" json:"spend_height,omitempty"` +} + +func (m *NullificationInfo) Reset() { *m = NullificationInfo{} } +func (m *NullificationInfo) String() string { return proto.CompactTextString(m) } +func (*NullificationInfo) ProtoMessage() {} +func (*NullificationInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{2} +} +func (m *NullificationInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NullificationInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NullificationInfo.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 *NullificationInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_NullificationInfo.Merge(m, src) +} +func (m *NullificationInfo) XXX_Size() int { + return m.Size() +} +func (m *NullificationInfo) XXX_DiscardUnknown() { + xxx_messageInfo_NullificationInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_NullificationInfo proto.InternalMessageInfo + +func (m *NullificationInfo) GetId() []byte { + if m != nil { + return m.Id + } + return nil +} + +func (m *NullificationInfo) GetSpendHeight() uint64 { + if m != nil { + return m.SpendHeight + } + return 0 +} + +// Event recording a new commitment added to the SCT. +type EventCommitment struct { + Commitment *v1alpha1.StateCommitment `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"` + Position uint64 `protobuf:"varint,2,opt,name=position,proto3" json:"position,omitempty"` + Source *CommitmentSource `protobuf:"bytes,3,opt,name=source,proto3" json:"source,omitempty"` +} + +func (m *EventCommitment) Reset() { *m = EventCommitment{} } +func (m *EventCommitment) String() string { return proto.CompactTextString(m) } +func (*EventCommitment) ProtoMessage() {} +func (*EventCommitment) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{3} +} +func (m *EventCommitment) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventCommitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventCommitment.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 *EventCommitment) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventCommitment.Merge(m, src) +} +func (m *EventCommitment) XXX_Size() int { + return m.Size() +} +func (m *EventCommitment) XXX_DiscardUnknown() { + xxx_messageInfo_EventCommitment.DiscardUnknown(m) +} + +var xxx_messageInfo_EventCommitment proto.InternalMessageInfo + +func (m *EventCommitment) GetCommitment() *v1alpha1.StateCommitment { + if m != nil { + return m.Commitment + } + return nil +} + +func (m *EventCommitment) GetPosition() uint64 { + if m != nil { + return m.Position + } + return 0 +} + +func (m *EventCommitment) GetSource() *CommitmentSource { + if m != nil { + return m.Source + } + return nil +} + +// Event recording an SCT anchor (global root). +type EventAnchor struct { + Anchor *v1alpha1.MerkleRoot `protobuf:"bytes,1,opt,name=anchor,proto3" json:"anchor,omitempty"` + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *EventAnchor) Reset() { *m = EventAnchor{} } +func (m *EventAnchor) String() string { return proto.CompactTextString(m) } +func (*EventAnchor) ProtoMessage() {} +func (*EventAnchor) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{4} +} +func (m *EventAnchor) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventAnchor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventAnchor.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 *EventAnchor) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventAnchor.Merge(m, src) +} +func (m *EventAnchor) XXX_Size() int { + return m.Size() +} +func (m *EventAnchor) XXX_DiscardUnknown() { + xxx_messageInfo_EventAnchor.DiscardUnknown(m) +} + +var xxx_messageInfo_EventAnchor proto.InternalMessageInfo + +func (m *EventAnchor) GetAnchor() *v1alpha1.MerkleRoot { + if m != nil { + return m.Anchor + } + return nil +} + +func (m *EventAnchor) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +// Event recording an SCT epoch root. +type EventEpochRoot struct { + Root *v1alpha1.MerkleRoot `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"` + Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` +} + +func (m *EventEpochRoot) Reset() { *m = EventEpochRoot{} } +func (m *EventEpochRoot) String() string { return proto.CompactTextString(m) } +func (*EventEpochRoot) ProtoMessage() {} +func (*EventEpochRoot) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{5} +} +func (m *EventEpochRoot) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventEpochRoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventEpochRoot.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 *EventEpochRoot) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventEpochRoot.Merge(m, src) +} +func (m *EventEpochRoot) XXX_Size() int { + return m.Size() +} +func (m *EventEpochRoot) XXX_DiscardUnknown() { + xxx_messageInfo_EventEpochRoot.DiscardUnknown(m) +} + +var xxx_messageInfo_EventEpochRoot proto.InternalMessageInfo + +func (m *EventEpochRoot) GetRoot() *v1alpha1.MerkleRoot { + if m != nil { + return m.Root + } + return nil +} + +func (m *EventEpochRoot) GetIndex() uint64 { + if m != nil { + return m.Index + } + return 0 +} + +// Event recording an SCT block root. +type EventBlockRoot struct { + Root *v1alpha1.MerkleRoot `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"` + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *EventBlockRoot) Reset() { *m = EventBlockRoot{} } +func (m *EventBlockRoot) String() string { return proto.CompactTextString(m) } +func (*EventBlockRoot) ProtoMessage() {} +func (*EventBlockRoot) Descriptor() ([]byte, []int) { + return fileDescriptor_e99589ee3b6c1a3a, []int{6} +} +func (m *EventBlockRoot) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventBlockRoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventBlockRoot.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 *EventBlockRoot) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventBlockRoot.Merge(m, src) +} +func (m *EventBlockRoot) XXX_Size() int { + return m.Size() +} +func (m *EventBlockRoot) XXX_DiscardUnknown() { + xxx_messageInfo_EventBlockRoot.DiscardUnknown(m) +} + +var xxx_messageInfo_EventBlockRoot proto.InternalMessageInfo + +func (m *EventBlockRoot) GetRoot() *v1alpha1.MerkleRoot { + if m != nil { + return m.Root + } + return nil +} + +func (m *EventBlockRoot) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func init() { + proto.RegisterType((*CommitmentSource)(nil), "penumbra.core.component.sct.v1alpha1.CommitmentSource") + proto.RegisterType((*CommitmentSource_Genesis)(nil), "penumbra.core.component.sct.v1alpha1.CommitmentSource.Genesis") + proto.RegisterType((*CommitmentSource_Transaction)(nil), "penumbra.core.component.sct.v1alpha1.CommitmentSource.Transaction") + proto.RegisterType((*CommitmentSource_FundingStreamReward)(nil), "penumbra.core.component.sct.v1alpha1.CommitmentSource.FundingStreamReward") + proto.RegisterType((*CommitmentSource_CommunityPoolOutput)(nil), "penumbra.core.component.sct.v1alpha1.CommitmentSource.CommunityPoolOutput") + proto.RegisterType((*CommitmentSource_Ics20Transfer)(nil), "penumbra.core.component.sct.v1alpha1.CommitmentSource.Ics20Transfer") + proto.RegisterType((*Nullifier)(nil), "penumbra.core.component.sct.v1alpha1.Nullifier") + proto.RegisterType((*NullificationInfo)(nil), "penumbra.core.component.sct.v1alpha1.NullificationInfo") + proto.RegisterType((*EventCommitment)(nil), "penumbra.core.component.sct.v1alpha1.EventCommitment") + proto.RegisterType((*EventAnchor)(nil), "penumbra.core.component.sct.v1alpha1.EventAnchor") + proto.RegisterType((*EventEpochRoot)(nil), "penumbra.core.component.sct.v1alpha1.EventEpochRoot") + proto.RegisterType((*EventBlockRoot)(nil), "penumbra.core.component.sct.v1alpha1.EventBlockRoot") +} + +func init() { + proto.RegisterFile("penumbra/core/component/sct/v1alpha1/sct.proto", fileDescriptor_e99589ee3b6c1a3a) +} + +var fileDescriptor_e99589ee3b6c1a3a = []byte{ + // 812 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcb, 0x8e, 0x1b, 0x45, + 0x14, 0xb5, 0xcd, 0xe0, 0x8c, 0xaf, 0x27, 0x13, 0xa8, 0x49, 0x90, 0x65, 0x29, 0x86, 0x58, 0x11, + 0xf2, 0x86, 0xee, 0x89, 0x91, 0xb2, 0x30, 0x08, 0x81, 0x4d, 0x12, 0x0f, 0xd2, 0x04, 0xd3, 0x1d, + 0xb1, 0x88, 0x2c, 0xb5, 0x6a, 0xaa, 0xaf, 0xed, 0xd2, 0x74, 0x57, 0x75, 0xaa, 0xaa, 0x07, 0x66, + 0xc7, 0x27, 0xf0, 0x0d, 0x2c, 0xf9, 0x00, 0xbe, 0x01, 0x21, 0x16, 0x59, 0xb2, 0x03, 0xcd, 0xec, + 0xf8, 0x0a, 0x54, 0xe5, 0x6e, 0xdb, 0x79, 0x80, 0x06, 0xc3, 0xc6, 0xea, 0x7b, 0x7c, 0xee, 0x39, + 0xf7, 0x51, 0xa5, 0x02, 0x2f, 0x43, 0x91, 0xa7, 0x27, 0x8a, 0xfa, 0x4c, 0x2a, 0xf4, 0x99, 0x4c, + 0x33, 0x29, 0x50, 0x18, 0x5f, 0x33, 0xe3, 0x9f, 0xdd, 0xa3, 0x49, 0xb6, 0xa0, 0xf7, 0x6c, 0xe0, + 0x65, 0x4a, 0x1a, 0x49, 0xee, 0x96, 0x7c, 0xcf, 0xf2, 0xbd, 0x15, 0xdf, 0xb3, 0x94, 0x92, 0xdf, + 0x7e, 0x7f, 0xad, 0xaa, 0xce, 0x33, 0x23, 0x7d, 0xb3, 0xa9, 0x66, 0x4a, 0xb5, 0xee, 0x4f, 0x75, + 0x78, 0x6b, 0x24, 0xd3, 0x94, 0x9b, 0x14, 0x85, 0x09, 0x65, 0xae, 0x18, 0x92, 0x19, 0x34, 0x8d, + 0xa2, 0x42, 0x53, 0x66, 0xb8, 0x14, 0xad, 0xea, 0x7b, 0xd5, 0x5e, 0xb3, 0x3f, 0xf4, 0xae, 0x62, + 0xec, 0xbd, 0x2c, 0xe6, 0x3d, 0x59, 0x2b, 0x8d, 0x2b, 0xc1, 0xa6, 0x30, 0x11, 0x70, 0x83, 0x33, + 0x1d, 0xf5, 0x0f, 0x23, 0x87, 0xce, 0x50, 0xb5, 0x6a, 0xce, 0xeb, 0xf3, 0x2d, 0xbd, 0x8e, 0x98, + 0xee, 0x1f, 0x3e, 0x29, 0xb4, 0xc6, 0x95, 0xe0, 0x3a, 0xdf, 0x04, 0xc8, 0x77, 0x55, 0xb8, 0x35, + 0xcb, 0x45, 0xcc, 0xc5, 0x3c, 0xd2, 0x46, 0x21, 0x4d, 0x23, 0x85, 0xdf, 0x50, 0x15, 0xb7, 0x6e, + 0x3a, 0xdb, 0x2f, 0xb6, 0xb4, 0x7d, 0xb8, 0xd4, 0x0c, 0x9d, 0x64, 0xe0, 0x14, 0xc7, 0x95, 0xe0, + 0x60, 0xf6, 0x2a, 0xec, 0x4a, 0x60, 0x32, 0x4d, 0x73, 0xc1, 0xcd, 0x79, 0x94, 0x49, 0x99, 0x44, + 0x32, 0x37, 0x59, 0x6e, 0x5a, 0x9d, 0xff, 0x54, 0xc2, 0xa8, 0xd4, 0x9c, 0x48, 0x99, 0x7c, 0xe9, + 0x14, 0x6d, 0x09, 0xec, 0x55, 0x98, 0x3c, 0x85, 0x6b, 0x73, 0x14, 0xa8, 0xb9, 0x6e, 0xf5, 0x9c, + 0xe7, 0x27, 0x5b, 0x7a, 0x3e, 0x5a, 0xaa, 0x8c, 0x2b, 0x41, 0x29, 0xd8, 0x6e, 0xc0, 0xb5, 0x02, + 0x6d, 0xdf, 0x86, 0xe6, 0xc6, 0xea, 0xc9, 0x3e, 0xd4, 0x78, 0xec, 0x8e, 0xd2, 0x5e, 0x50, 0xe3, + 0x71, 0xfb, 0x3e, 0x1c, 0xbc, 0x66, 0x6c, 0xe4, 0x5d, 0x68, 0x62, 0x26, 0xd9, 0x22, 0xe2, 0x22, + 0xc6, 0x6f, 0x1d, 0x7f, 0x27, 0x00, 0x07, 0x1d, 0x59, 0xa4, 0x7d, 0x0b, 0x0e, 0x5e, 0xd3, 0x6b, + 0x1b, 0xe1, 0xfa, 0x0b, 0xcb, 0x27, 0xb7, 0x01, 0x32, 0xca, 0x4e, 0xd1, 0x44, 0x1a, 0x9f, 0x15, + 0x3a, 0x8d, 0x25, 0x12, 0xe2, 0x33, 0xfb, 0x37, 0x5b, 0x50, 0x21, 0x30, 0x89, 0x78, 0xec, 0x4e, + 0x5d, 0x23, 0x68, 0x14, 0xc8, 0x51, 0x4c, 0xde, 0x81, 0xba, 0x46, 0x11, 0xa3, 0x6a, 0xbd, 0xe1, + 0xfe, 0x2a, 0xa2, 0xe1, 0x2e, 0xd4, 0xb5, 0x6b, 0xbe, 0x7b, 0x07, 0x1a, 0x8f, 0xf3, 0x24, 0xe1, + 0x33, 0x8e, 0x8a, 0xdc, 0x84, 0x37, 0xb9, 0x10, 0xa8, 0x8a, 0xfe, 0x96, 0x41, 0xf7, 0x21, 0xbc, + 0x5d, 0x50, 0x18, 0xb5, 0x33, 0x38, 0x12, 0x33, 0xf9, 0xf2, 0x1c, 0xc8, 0x1d, 0xd8, 0xd3, 0x19, + 0x8a, 0x38, 0x5a, 0x20, 0x9f, 0x2f, 0x8c, 0x2b, 0x65, 0x27, 0x68, 0x3a, 0x6c, 0xec, 0xa0, 0xee, + 0xaf, 0x55, 0xb8, 0xf1, 0xe0, 0x0c, 0x85, 0x59, 0x6f, 0x80, 0x1c, 0x03, 0xb0, 0x55, 0x54, 0xdc, + 0xd0, 0x0f, 0x36, 0xf6, 0xe8, 0x2e, 0xbd, 0x67, 0x36, 0xf7, 0x17, 0x1a, 0x6a, 0x70, 0x2d, 0x11, + 0x6c, 0x08, 0x90, 0x36, 0xec, 0x66, 0x52, 0x73, 0x77, 0xdd, 0x97, 0x15, 0xac, 0x62, 0xf2, 0xb8, + 0xec, 0xd9, 0xcd, 0xa2, 0xd9, 0xbf, 0xbf, 0xdd, 0x71, 0x09, 0xca, 0xc9, 0xcd, 0xa1, 0xe9, 0xba, + 0xf9, 0x4c, 0xb0, 0x85, 0x54, 0xe4, 0x53, 0xa8, 0x53, 0xf7, 0x55, 0x74, 0xd1, 0xfb, 0xe7, 0x2e, + 0x8e, 0x51, 0x9d, 0x26, 0x18, 0x48, 0x69, 0x82, 0x22, 0xcf, 0x2e, 0xeb, 0x85, 0xe1, 0x15, 0x51, + 0x37, 0x86, 0x7d, 0x67, 0xf4, 0xc0, 0x9e, 0x1e, 0x9b, 0x41, 0x3e, 0x86, 0x1d, 0x25, 0xa5, 0xf9, + 0xd7, 0x4e, 0x2e, 0x6b, 0xb9, 0x65, 0x7b, 0x2a, 0x97, 0x36, 0xcb, 0xa0, 0x3b, 0x2b, 0x5c, 0x86, + 0x89, 0x64, 0xa7, 0xff, 0x83, 0xcb, 0xdf, 0x74, 0xd3, 0xdf, 0x87, 0xbd, 0xaf, 0x72, 0x54, 0xe7, + 0x21, 0xaa, 0x33, 0xce, 0x70, 0xf8, 0x7b, 0xed, 0xe7, 0x8b, 0x4e, 0xf5, 0xf9, 0x45, 0xa7, 0xfa, + 0xc7, 0x45, 0xa7, 0xfa, 0xfd, 0x65, 0xa7, 0xf2, 0xfc, 0xb2, 0x53, 0xf9, 0xed, 0xb2, 0x53, 0x81, + 0x1e, 0x93, 0xe9, 0x95, 0x96, 0x34, 0xdc, 0x0d, 0x99, 0x99, 0xd8, 0x87, 0x60, 0x52, 0x7d, 0x3a, + 0x9d, 0x73, 0xb3, 0xc8, 0x4f, 0x2c, 0xd5, 0x67, 0x52, 0xa7, 0x52, 0xfb, 0x0a, 0x13, 0x7a, 0x8e, + 0xca, 0x3f, 0xeb, 0xaf, 0x3e, 0xd9, 0x82, 0x72, 0xa1, 0xfd, 0xab, 0x3c, 0x5a, 0x1f, 0x69, 0x66, + 0xca, 0xef, 0x1f, 0x6a, 0x3b, 0x93, 0xd1, 0x28, 0xfc, 0xb1, 0x76, 0x77, 0x52, 0xd6, 0x35, 0xb2, + 0x75, 0x8d, 0x56, 0x75, 0x85, 0xcc, 0x78, 0x5f, 0x17, 0xec, 0x5f, 0xd6, 0xb4, 0xa9, 0xa5, 0x4d, + 0x57, 0xb4, 0x69, 0xc8, 0xcc, 0xb4, 0xa4, 0x5d, 0xd4, 0x0e, 0xaf, 0x42, 0x9b, 0x3e, 0x9a, 0x0c, + 0x8f, 0xd1, 0xd0, 0x98, 0x1a, 0xfa, 0x67, 0xad, 0x57, 0xa6, 0x0c, 0x06, 0x36, 0xc7, 0xfe, 0x16, + 0x49, 0x83, 0x41, 0xc8, 0xcc, 0x60, 0x50, 0xa6, 0x9d, 0xd4, 0xdd, 0x13, 0xf9, 0xe1, 0x5f, 0x01, + 0x00, 0x00, 0xff, 0xff, 0xc7, 0xd6, 0x7d, 0xcb, 0xa2, 0x07, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.sct.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{}, + Metadata: "penumbra/core/component/sct/v1alpha1/sct.proto", +} + +func (m *CommitmentSource) 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 *CommitmentSource) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Source != nil { + { + size := m.Source.Size() + i -= size + if _, err := m.Source.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *CommitmentSource_Transaction_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_Transaction_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Transaction != nil { + { + size, err := m.Transaction.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *CommitmentSource_Ics_20Transfer) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_Ics_20Transfer) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Ics_20Transfer != nil { + { + size, err := m.Ics_20Transfer.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *CommitmentSource_FundingStreamReward_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_FundingStreamReward_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.FundingStreamReward != nil { + { + size, err := m.FundingStreamReward.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *CommitmentSource_CommunityPoolOutput_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_CommunityPoolOutput_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.CommunityPoolOutput != nil { + { + size, err := m.CommunityPoolOutput.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *CommitmentSource_Genesis_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_Genesis_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Genesis != nil { + { + size, err := m.Genesis.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *CommitmentSource_Genesis) 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 *CommitmentSource_Genesis) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_Genesis) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *CommitmentSource_Transaction) 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 *CommitmentSource_Transaction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_Transaction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintSct(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CommitmentSource_FundingStreamReward) 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 *CommitmentSource_FundingStreamReward) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_FundingStreamReward) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EpochIndex != 0 { + i = encodeVarintSct(dAtA, i, uint64(m.EpochIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *CommitmentSource_CommunityPoolOutput) 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 *CommitmentSource_CommunityPoolOutput) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_CommunityPoolOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *CommitmentSource_Ics20Transfer) 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 *CommitmentSource_Ics20Transfer) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitmentSource_Ics20Transfer) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintSct(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0x1a + } + if len(m.ChannelId) > 0 { + i -= len(m.ChannelId) + copy(dAtA[i:], m.ChannelId) + i = encodeVarintSct(dAtA, i, uint64(len(m.ChannelId))) + i-- + dAtA[i] = 0x12 + } + if m.PacketSeq != 0 { + i = encodeVarintSct(dAtA, i, uint64(m.PacketSeq)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Nullifier) 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 *Nullifier) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Nullifier) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintSct(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *NullificationInfo) 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 *NullificationInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NullificationInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SpendHeight != 0 { + i = encodeVarintSct(dAtA, i, uint64(m.SpendHeight)) + i-- + dAtA[i] = 0x10 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintSct(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventCommitment) 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 *EventCommitment) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Source != nil { + { + size, err := m.Source.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Position != 0 { + i = encodeVarintSct(dAtA, i, uint64(m.Position)) + i-- + dAtA[i] = 0x10 + } + if m.Commitment != nil { + { + size, err := m.Commitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventAnchor) 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 *EventAnchor) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventAnchor) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintSct(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if m.Anchor != nil { + { + size, err := m.Anchor.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventEpochRoot) 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 *EventEpochRoot) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventEpochRoot) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Index != 0 { + i = encodeVarintSct(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x10 + } + if m.Root != nil { + { + size, err := m.Root.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventBlockRoot) 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 *EventBlockRoot) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventBlockRoot) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintSct(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if m.Root != nil { + { + size, err := m.Root.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintSct(dAtA []byte, offset int, v uint64) int { + offset -= sovSct(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *CommitmentSource) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != nil { + n += m.Source.Size() + } + return n +} + +func (m *CommitmentSource_Transaction_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Transaction != nil { + l = m.Transaction.Size() + n += 1 + l + sovSct(uint64(l)) + } + return n +} +func (m *CommitmentSource_Ics_20Transfer) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Ics_20Transfer != nil { + l = m.Ics_20Transfer.Size() + n += 1 + l + sovSct(uint64(l)) + } + return n +} +func (m *CommitmentSource_FundingStreamReward_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FundingStreamReward != nil { + l = m.FundingStreamReward.Size() + n += 2 + l + sovSct(uint64(l)) + } + return n +} +func (m *CommitmentSource_CommunityPoolOutput_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CommunityPoolOutput != nil { + l = m.CommunityPoolOutput.Size() + n += 2 + l + sovSct(uint64(l)) + } + return n +} +func (m *CommitmentSource_Genesis_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Genesis != nil { + l = m.Genesis.Size() + n += 2 + l + sovSct(uint64(l)) + } + return n +} +func (m *CommitmentSource_Genesis) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *CommitmentSource_Transaction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovSct(uint64(l)) + } + return n +} + +func (m *CommitmentSource_FundingStreamReward) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EpochIndex != 0 { + n += 1 + sovSct(uint64(m.EpochIndex)) + } + return n +} + +func (m *CommitmentSource_CommunityPoolOutput) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *CommitmentSource_Ics20Transfer) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PacketSeq != 0 { + n += 1 + sovSct(uint64(m.PacketSeq)) + } + l = len(m.ChannelId) + if l > 0 { + n += 1 + l + sovSct(uint64(l)) + } + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovSct(uint64(l)) + } + return n +} + +func (m *Nullifier) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovSct(uint64(l)) + } + return n +} + +func (m *NullificationInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovSct(uint64(l)) + } + if m.SpendHeight != 0 { + n += 1 + sovSct(uint64(m.SpendHeight)) + } + return n +} + +func (m *EventCommitment) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Commitment != nil { + l = m.Commitment.Size() + n += 1 + l + sovSct(uint64(l)) + } + if m.Position != 0 { + n += 1 + sovSct(uint64(m.Position)) + } + if m.Source != nil { + l = m.Source.Size() + n += 1 + l + sovSct(uint64(l)) + } + return n +} + +func (m *EventAnchor) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Anchor != nil { + l = m.Anchor.Size() + n += 1 + l + sovSct(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovSct(uint64(m.Height)) + } + return n +} + +func (m *EventEpochRoot) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Root != nil { + l = m.Root.Size() + n += 1 + l + sovSct(uint64(l)) + } + if m.Index != 0 { + n += 1 + sovSct(uint64(m.Index)) + } + return n +} + +func (m *EventBlockRoot) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Root != nil { + l = m.Root.Size() + n += 1 + l + sovSct(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovSct(uint64(m.Height)) + } + return n +} + +func sovSct(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozSct(x uint64) (n int) { + return sovSct(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *CommitmentSource) 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 ErrIntOverflowSct + } + 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: CommitmentSource: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommitmentSource: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transaction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &CommitmentSource_Transaction{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Source = &CommitmentSource_Transaction_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ics_20Transfer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &CommitmentSource_Ics20Transfer{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Source = &CommitmentSource_Ics_20Transfer{v} + iNdEx = postIndex + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FundingStreamReward", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &CommitmentSource_FundingStreamReward{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Source = &CommitmentSource_FundingStreamReward_{v} + iNdEx = postIndex + case 30: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolOutput", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &CommitmentSource_CommunityPoolOutput{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Source = &CommitmentSource_CommunityPoolOutput_{v} + iNdEx = postIndex + case 40: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Genesis", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &CommitmentSource_Genesis{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Source = &CommitmentSource_Genesis_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommitmentSource_Genesis) 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 ErrIntOverflowSct + } + 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: Genesis: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Genesis: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommitmentSource_Transaction) 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 ErrIntOverflowSct + } + 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: Transaction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Transaction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = append(m.Id[:0], dAtA[iNdEx:postIndex]...) + if m.Id == nil { + m.Id = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommitmentSource_FundingStreamReward) 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 ErrIntOverflowSct + } + 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: FundingStreamReward: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FundingStreamReward: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType) + } + m.EpochIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EpochIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommitmentSource_CommunityPoolOutput) 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 ErrIntOverflowSct + } + 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: CommunityPoolOutput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommunityPoolOutput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommitmentSource_Ics20Transfer) 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 ErrIntOverflowSct + } + 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: Ics20Transfer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Ics20Transfer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PacketSeq", wireType) + } + m.PacketSeq = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PacketSeq |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + 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 ErrInvalidLengthSct + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChannelId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + 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 ErrInvalidLengthSct + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Nullifier) 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 ErrIntOverflowSct + } + 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: Nullifier: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nullifier: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NullificationInfo) 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 ErrIntOverflowSct + } + 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: NullificationInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NullificationInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = append(m.Id[:0], dAtA[iNdEx:postIndex]...) + if m.Id == nil { + m.Id = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SpendHeight", wireType) + } + m.SpendHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SpendHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventCommitment) 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 ErrIntOverflowSct + } + 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: EventCommitment: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventCommitment: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Commitment == nil { + m.Commitment = &v1alpha1.StateCommitment{} + } + if err := m.Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) + } + m.Position = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Position |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = &CommitmentSource{} + } + if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventAnchor) 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 ErrIntOverflowSct + } + 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: EventAnchor: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventAnchor: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Anchor", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Anchor == nil { + m.Anchor = &v1alpha1.MerkleRoot{} + } + if err := m.Anchor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventEpochRoot) 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 ErrIntOverflowSct + } + 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: EventEpochRoot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventEpochRoot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Root == nil { + m.Root = &v1alpha1.MerkleRoot{} + } + if err := m.Root.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventBlockRoot) 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 ErrIntOverflowSct + } + 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: EventBlockRoot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventBlockRoot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Root == nil { + m.Root = &v1alpha1.MerkleRoot{} + } + if err := m.Root.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSct(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, ErrIntOverflowSct + } + 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, ErrIntOverflowSct + } + 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, ErrIntOverflowSct + } + 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, ErrInvalidLengthSct + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupSct + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthSct + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthSct = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSct = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupSct = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.pb.go b/relayer/chains/penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.pb.go new file mode 100644 index 000000000..2c1b00690 --- /dev/null +++ b/relayer/chains/penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.pb.go @@ -0,0 +1,6764 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.proto + +package shielded_poolv1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + v1alpha14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1" + v1alpha15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" + v1alpha13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_rdsa/v1alpha1" + v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +type Note struct { + Value *v1alpha1.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + Rseed []byte `protobuf:"bytes,2,opt,name=rseed,proto3" json:"rseed,omitempty"` + Address *v1alpha11.Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *Note) Reset() { *m = Note{} } +func (m *Note) String() string { return proto.CompactTextString(m) } +func (*Note) ProtoMessage() {} +func (*Note) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{0} +} +func (m *Note) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Note) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Note.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 *Note) XXX_Merge(src proto.Message) { + xxx_messageInfo_Note.Merge(m, src) +} +func (m *Note) XXX_Size() int { + return m.Size() +} +func (m *Note) XXX_DiscardUnknown() { + xxx_messageInfo_Note.DiscardUnknown(m) +} + +var xxx_messageInfo_Note proto.InternalMessageInfo + +func (m *Note) GetValue() *v1alpha1.Value { + if m != nil { + return m.Value + } + return nil +} + +func (m *Note) GetRseed() []byte { + if m != nil { + return m.Rseed + } + return nil +} + +func (m *Note) GetAddress() *v1alpha11.Address { + if m != nil { + return m.Address + } + return nil +} + +type NoteView struct { + Value *v1alpha1.ValueView `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + Rseed []byte `protobuf:"bytes,2,opt,name=rseed,proto3" json:"rseed,omitempty"` + Address *v1alpha11.AddressView `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *NoteView) Reset() { *m = NoteView{} } +func (m *NoteView) String() string { return proto.CompactTextString(m) } +func (*NoteView) ProtoMessage() {} +func (*NoteView) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{1} +} +func (m *NoteView) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NoteView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NoteView.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 *NoteView) XXX_Merge(src proto.Message) { + xxx_messageInfo_NoteView.Merge(m, src) +} +func (m *NoteView) XXX_Size() int { + return m.Size() +} +func (m *NoteView) XXX_DiscardUnknown() { + xxx_messageInfo_NoteView.DiscardUnknown(m) +} + +var xxx_messageInfo_NoteView proto.InternalMessageInfo + +func (m *NoteView) GetValue() *v1alpha1.ValueView { + if m != nil { + return m.Value + } + return nil +} + +func (m *NoteView) GetRseed() []byte { + if m != nil { + return m.Rseed + } + return nil +} + +func (m *NoteView) GetAddress() *v1alpha11.AddressView { + if m != nil { + return m.Address + } + return nil +} + +// An encrypted note. +// 132 = 1(type) + 11(d) + 8(amount) + 32(asset_id) + 32(rcm) + 32(pk_d) + 16(MAC) bytes. +type NoteCiphertext struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *NoteCiphertext) Reset() { *m = NoteCiphertext{} } +func (m *NoteCiphertext) String() string { return proto.CompactTextString(m) } +func (*NoteCiphertext) ProtoMessage() {} +func (*NoteCiphertext) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{2} +} +func (m *NoteCiphertext) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NoteCiphertext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NoteCiphertext.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 *NoteCiphertext) XXX_Merge(src proto.Message) { + xxx_messageInfo_NoteCiphertext.Merge(m, src) +} +func (m *NoteCiphertext) XXX_Size() int { + return m.Size() +} +func (m *NoteCiphertext) XXX_DiscardUnknown() { + xxx_messageInfo_NoteCiphertext.DiscardUnknown(m) +} + +var xxx_messageInfo_NoteCiphertext proto.InternalMessageInfo + +func (m *NoteCiphertext) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// The body of an output description, including only the minimal +// data required to scan and process the output. +type NotePayload struct { + // The note commitment for the output note. 32 bytes. + NoteCommitment *v1alpha12.StateCommitment `protobuf:"bytes,1,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` + // The encoding of an ephemeral public key. 32 bytes. + EphemeralKey []byte `protobuf:"bytes,2,opt,name=ephemeral_key,json=ephemeralKey,proto3" json:"ephemeral_key,omitempty"` + // An encryption of the newly created note. + // 132 = 1(type) + 11(d) + 8(amount) + 32(asset_id) + 32(rcm) + 32(pk_d) + 16(MAC) bytes. + EncryptedNote *NoteCiphertext `protobuf:"bytes,3,opt,name=encrypted_note,json=encryptedNote,proto3" json:"encrypted_note,omitempty"` +} + +func (m *NotePayload) Reset() { *m = NotePayload{} } +func (m *NotePayload) String() string { return proto.CompactTextString(m) } +func (*NotePayload) ProtoMessage() {} +func (*NotePayload) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{3} +} +func (m *NotePayload) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NotePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NotePayload.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 *NotePayload) XXX_Merge(src proto.Message) { + xxx_messageInfo_NotePayload.Merge(m, src) +} +func (m *NotePayload) XXX_Size() int { + return m.Size() +} +func (m *NotePayload) XXX_DiscardUnknown() { + xxx_messageInfo_NotePayload.DiscardUnknown(m) +} + +var xxx_messageInfo_NotePayload proto.InternalMessageInfo + +func (m *NotePayload) GetNoteCommitment() *v1alpha12.StateCommitment { + if m != nil { + return m.NoteCommitment + } + return nil +} + +func (m *NotePayload) GetEphemeralKey() []byte { + if m != nil { + return m.EphemeralKey + } + return nil +} + +func (m *NotePayload) GetEncryptedNote() *NoteCiphertext { + if m != nil { + return m.EncryptedNote + } + return nil +} + +// A Penumbra ZK output proof. +type ZKOutputProof struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *ZKOutputProof) Reset() { *m = ZKOutputProof{} } +func (m *ZKOutputProof) String() string { return proto.CompactTextString(m) } +func (*ZKOutputProof) ProtoMessage() {} +func (*ZKOutputProof) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{4} +} +func (m *ZKOutputProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZKOutputProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZKOutputProof.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 *ZKOutputProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZKOutputProof.Merge(m, src) +} +func (m *ZKOutputProof) XXX_Size() int { + return m.Size() +} +func (m *ZKOutputProof) XXX_DiscardUnknown() { + xxx_messageInfo_ZKOutputProof.DiscardUnknown(m) +} + +var xxx_messageInfo_ZKOutputProof proto.InternalMessageInfo + +func (m *ZKOutputProof) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// A Penumbra ZK spend proof. +type ZKSpendProof struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *ZKSpendProof) Reset() { *m = ZKSpendProof{} } +func (m *ZKSpendProof) String() string { return proto.CompactTextString(m) } +func (*ZKSpendProof) ProtoMessage() {} +func (*ZKSpendProof) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{5} +} +func (m *ZKSpendProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZKSpendProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZKSpendProof.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 *ZKSpendProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZKSpendProof.Merge(m, src) +} +func (m *ZKSpendProof) XXX_Size() int { + return m.Size() +} +func (m *ZKSpendProof) XXX_DiscardUnknown() { + xxx_messageInfo_ZKSpendProof.DiscardUnknown(m) +} + +var xxx_messageInfo_ZKSpendProof proto.InternalMessageInfo + +func (m *ZKSpendProof) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// A Penumbra ZK nullifier derivation proof. +type ZKNullifierDerivationProof struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *ZKNullifierDerivationProof) Reset() { *m = ZKNullifierDerivationProof{} } +func (m *ZKNullifierDerivationProof) String() string { return proto.CompactTextString(m) } +func (*ZKNullifierDerivationProof) ProtoMessage() {} +func (*ZKNullifierDerivationProof) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{6} +} +func (m *ZKNullifierDerivationProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZKNullifierDerivationProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZKNullifierDerivationProof.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 *ZKNullifierDerivationProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZKNullifierDerivationProof.Merge(m, src) +} +func (m *ZKNullifierDerivationProof) XXX_Size() int { + return m.Size() +} +func (m *ZKNullifierDerivationProof) XXX_DiscardUnknown() { + xxx_messageInfo_ZKNullifierDerivationProof.DiscardUnknown(m) +} + +var xxx_messageInfo_ZKNullifierDerivationProof proto.InternalMessageInfo + +func (m *ZKNullifierDerivationProof) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// Spends a shielded note. +type Spend struct { + // The effecting data of the spend. + Body *SpendBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` + // The authorizing signature for the spend. + AuthSig *v1alpha13.SpendAuthSignature `protobuf:"bytes,2,opt,name=auth_sig,json=authSig,proto3" json:"auth_sig,omitempty"` + // The proof that the spend is well-formed is authorizing data. + Proof *ZKSpendProof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"` +} + +func (m *Spend) Reset() { *m = Spend{} } +func (m *Spend) String() string { return proto.CompactTextString(m) } +func (*Spend) ProtoMessage() {} +func (*Spend) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{7} +} +func (m *Spend) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Spend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Spend.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 *Spend) XXX_Merge(src proto.Message) { + xxx_messageInfo_Spend.Merge(m, src) +} +func (m *Spend) XXX_Size() int { + return m.Size() +} +func (m *Spend) XXX_DiscardUnknown() { + xxx_messageInfo_Spend.DiscardUnknown(m) +} + +var xxx_messageInfo_Spend proto.InternalMessageInfo + +func (m *Spend) GetBody() *SpendBody { + if m != nil { + return m.Body + } + return nil +} + +func (m *Spend) GetAuthSig() *v1alpha13.SpendAuthSignature { + if m != nil { + return m.AuthSig + } + return nil +} + +func (m *Spend) GetProof() *ZKSpendProof { + if m != nil { + return m.Proof + } + return nil +} + +// ABCI Event recording a spend. +type EventSpend struct { + Nullifier *v1alpha14.Nullifier `protobuf:"bytes,1,opt,name=nullifier,proto3" json:"nullifier,omitempty"` +} + +func (m *EventSpend) Reset() { *m = EventSpend{} } +func (m *EventSpend) String() string { return proto.CompactTextString(m) } +func (*EventSpend) ProtoMessage() {} +func (*EventSpend) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{8} +} +func (m *EventSpend) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventSpend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventSpend.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 *EventSpend) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventSpend.Merge(m, src) +} +func (m *EventSpend) XXX_Size() int { + return m.Size() +} +func (m *EventSpend) XXX_DiscardUnknown() { + xxx_messageInfo_EventSpend.DiscardUnknown(m) +} + +var xxx_messageInfo_EventSpend proto.InternalMessageInfo + +func (m *EventSpend) GetNullifier() *v1alpha14.Nullifier { + if m != nil { + return m.Nullifier + } + return nil +} + +// ABCI Event recording an output. +type EventOutput struct { + NoteCommitment *v1alpha12.StateCommitment `protobuf:"bytes,1,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` +} + +func (m *EventOutput) Reset() { *m = EventOutput{} } +func (m *EventOutput) String() string { return proto.CompactTextString(m) } +func (*EventOutput) ProtoMessage() {} +func (*EventOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{9} +} +func (m *EventOutput) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventOutput.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 *EventOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventOutput.Merge(m, src) +} +func (m *EventOutput) XXX_Size() int { + return m.Size() +} +func (m *EventOutput) XXX_DiscardUnknown() { + xxx_messageInfo_EventOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_EventOutput proto.InternalMessageInfo + +func (m *EventOutput) GetNoteCommitment() *v1alpha12.StateCommitment { + if m != nil { + return m.NoteCommitment + } + return nil +} + +// The body of a spend description, containing only the effecting data +// describing changes to the ledger, and not the authorizing data that allows +// those changes to be performed. +type SpendBody struct { + // A commitment to the value of the input note. + BalanceCommitment *v1alpha1.BalanceCommitment `protobuf:"bytes,1,opt,name=balance_commitment,json=balanceCommitment,proto3" json:"balance_commitment,omitempty"` + // The nullifier of the input note. + Nullifier *v1alpha14.Nullifier `protobuf:"bytes,6,opt,name=nullifier,proto3" json:"nullifier,omitempty"` + // The randomized validating key for the spend authorization signature. + Rk *v1alpha13.SpendVerificationKey `protobuf:"bytes,4,opt,name=rk,proto3" json:"rk,omitempty"` +} + +func (m *SpendBody) Reset() { *m = SpendBody{} } +func (m *SpendBody) String() string { return proto.CompactTextString(m) } +func (*SpendBody) ProtoMessage() {} +func (*SpendBody) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{10} +} +func (m *SpendBody) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpendBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpendBody.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 *SpendBody) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpendBody.Merge(m, src) +} +func (m *SpendBody) XXX_Size() int { + return m.Size() +} +func (m *SpendBody) XXX_DiscardUnknown() { + xxx_messageInfo_SpendBody.DiscardUnknown(m) +} + +var xxx_messageInfo_SpendBody proto.InternalMessageInfo + +func (m *SpendBody) GetBalanceCommitment() *v1alpha1.BalanceCommitment { + if m != nil { + return m.BalanceCommitment + } + return nil +} + +func (m *SpendBody) GetNullifier() *v1alpha14.Nullifier { + if m != nil { + return m.Nullifier + } + return nil +} + +func (m *SpendBody) GetRk() *v1alpha13.SpendVerificationKey { + if m != nil { + return m.Rk + } + return nil +} + +type SpendView struct { + // Types that are valid to be assigned to SpendView: + // + // *SpendView_Visible_ + // *SpendView_Opaque_ + SpendView isSpendView_SpendView `protobuf_oneof:"spend_view"` +} + +func (m *SpendView) Reset() { *m = SpendView{} } +func (m *SpendView) String() string { return proto.CompactTextString(m) } +func (*SpendView) ProtoMessage() {} +func (*SpendView) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{11} +} +func (m *SpendView) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpendView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpendView.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 *SpendView) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpendView.Merge(m, src) +} +func (m *SpendView) XXX_Size() int { + return m.Size() +} +func (m *SpendView) XXX_DiscardUnknown() { + xxx_messageInfo_SpendView.DiscardUnknown(m) +} + +var xxx_messageInfo_SpendView proto.InternalMessageInfo + +type isSpendView_SpendView interface { + isSpendView_SpendView() + MarshalTo([]byte) (int, error) + Size() int +} + +type SpendView_Visible_ struct { + Visible *SpendView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` +} +type SpendView_Opaque_ struct { + Opaque *SpendView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +} + +func (*SpendView_Visible_) isSpendView_SpendView() {} +func (*SpendView_Opaque_) isSpendView_SpendView() {} + +func (m *SpendView) GetSpendView() isSpendView_SpendView { + if m != nil { + return m.SpendView + } + return nil +} + +func (m *SpendView) GetVisible() *SpendView_Visible { + if x, ok := m.GetSpendView().(*SpendView_Visible_); ok { + return x.Visible + } + return nil +} + +func (m *SpendView) GetOpaque() *SpendView_Opaque { + if x, ok := m.GetSpendView().(*SpendView_Opaque_); ok { + return x.Opaque + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*SpendView) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*SpendView_Visible_)(nil), + (*SpendView_Opaque_)(nil), + } +} + +type SpendView_Visible struct { + Spend *Spend `protobuf:"bytes,1,opt,name=spend,proto3" json:"spend,omitempty"` + Note *NoteView `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` +} + +func (m *SpendView_Visible) Reset() { *m = SpendView_Visible{} } +func (m *SpendView_Visible) String() string { return proto.CompactTextString(m) } +func (*SpendView_Visible) ProtoMessage() {} +func (*SpendView_Visible) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{11, 0} +} +func (m *SpendView_Visible) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpendView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpendView_Visible.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 *SpendView_Visible) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpendView_Visible.Merge(m, src) +} +func (m *SpendView_Visible) XXX_Size() int { + return m.Size() +} +func (m *SpendView_Visible) XXX_DiscardUnknown() { + xxx_messageInfo_SpendView_Visible.DiscardUnknown(m) +} + +var xxx_messageInfo_SpendView_Visible proto.InternalMessageInfo + +func (m *SpendView_Visible) GetSpend() *Spend { + if m != nil { + return m.Spend + } + return nil +} + +func (m *SpendView_Visible) GetNote() *NoteView { + if m != nil { + return m.Note + } + return nil +} + +type SpendView_Opaque struct { + Spend *Spend `protobuf:"bytes,1,opt,name=spend,proto3" json:"spend,omitempty"` +} + +func (m *SpendView_Opaque) Reset() { *m = SpendView_Opaque{} } +func (m *SpendView_Opaque) String() string { return proto.CompactTextString(m) } +func (*SpendView_Opaque) ProtoMessage() {} +func (*SpendView_Opaque) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{11, 1} +} +func (m *SpendView_Opaque) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpendView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpendView_Opaque.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 *SpendView_Opaque) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpendView_Opaque.Merge(m, src) +} +func (m *SpendView_Opaque) XXX_Size() int { + return m.Size() +} +func (m *SpendView_Opaque) XXX_DiscardUnknown() { + xxx_messageInfo_SpendView_Opaque.DiscardUnknown(m) +} + +var xxx_messageInfo_SpendView_Opaque proto.InternalMessageInfo + +func (m *SpendView_Opaque) GetSpend() *Spend { + if m != nil { + return m.Spend + } + return nil +} + +type SpendPlan struct { + // The plaintext note we plan to spend. + Note *Note `protobuf:"bytes,1,opt,name=note,proto3" json:"note,omitempty"` + // The position of the note we plan to spend. + Position uint64 `protobuf:"varint,2,opt,name=position,proto3" json:"position,omitempty"` + // The randomizer to use for the spend. + Randomizer []byte `protobuf:"bytes,3,opt,name=randomizer,proto3" json:"randomizer,omitempty"` + // The blinding factor to use for the value commitment. + ValueBlinding []byte `protobuf:"bytes,4,opt,name=value_blinding,json=valueBlinding,proto3" json:"value_blinding,omitempty"` + // The first blinding factor to use for the ZK spend proof. + ProofBlindingR []byte `protobuf:"bytes,5,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` + // The second blinding factor to use for the ZK spend proof. + ProofBlindingS []byte `protobuf:"bytes,6,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` +} + +func (m *SpendPlan) Reset() { *m = SpendPlan{} } +func (m *SpendPlan) String() string { return proto.CompactTextString(m) } +func (*SpendPlan) ProtoMessage() {} +func (*SpendPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{12} +} +func (m *SpendPlan) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpendPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpendPlan.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 *SpendPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpendPlan.Merge(m, src) +} +func (m *SpendPlan) XXX_Size() int { + return m.Size() +} +func (m *SpendPlan) XXX_DiscardUnknown() { + xxx_messageInfo_SpendPlan.DiscardUnknown(m) +} + +var xxx_messageInfo_SpendPlan proto.InternalMessageInfo + +func (m *SpendPlan) GetNote() *Note { + if m != nil { + return m.Note + } + return nil +} + +func (m *SpendPlan) GetPosition() uint64 { + if m != nil { + return m.Position + } + return 0 +} + +func (m *SpendPlan) GetRandomizer() []byte { + if m != nil { + return m.Randomizer + } + return nil +} + +func (m *SpendPlan) GetValueBlinding() []byte { + if m != nil { + return m.ValueBlinding + } + return nil +} + +func (m *SpendPlan) GetProofBlindingR() []byte { + if m != nil { + return m.ProofBlindingR + } + return nil +} + +func (m *SpendPlan) GetProofBlindingS() []byte { + if m != nil { + return m.ProofBlindingS + } + return nil +} + +// Creates a new shielded note. +type Output struct { + // The effecting data for the output. + Body *OutputBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` + // The output proof is authorizing data. + Proof *ZKOutputProof `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` +} + +func (m *Output) Reset() { *m = Output{} } +func (m *Output) String() string { return proto.CompactTextString(m) } +func (*Output) ProtoMessage() {} +func (*Output) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{13} +} +func (m *Output) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Output) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Output.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 *Output) XXX_Merge(src proto.Message) { + xxx_messageInfo_Output.Merge(m, src) +} +func (m *Output) XXX_Size() int { + return m.Size() +} +func (m *Output) XXX_DiscardUnknown() { + xxx_messageInfo_Output.DiscardUnknown(m) +} + +var xxx_messageInfo_Output proto.InternalMessageInfo + +func (m *Output) GetBody() *OutputBody { + if m != nil { + return m.Body + } + return nil +} + +func (m *Output) GetProof() *ZKOutputProof { + if m != nil { + return m.Proof + } + return nil +} + +// The body of an output description, containing only the effecting data +// describing changes to the ledger, and not the authorizing data that allows +// those changes to be performed. +type OutputBody struct { + // The minimal data required to scan and process the new output note. + NotePayload *NotePayload `protobuf:"bytes,1,opt,name=note_payload,json=notePayload,proto3" json:"note_payload,omitempty"` + // A commitment to the value of the output note. 32 bytes. + BalanceCommitment *v1alpha1.BalanceCommitment `protobuf:"bytes,2,opt,name=balance_commitment,json=balanceCommitment,proto3" json:"balance_commitment,omitempty"` + // An encrypted key for decrypting the memo. + WrappedMemoKey []byte `protobuf:"bytes,3,opt,name=wrapped_memo_key,json=wrappedMemoKey,proto3" json:"wrapped_memo_key,omitempty"` + // The key material used for note encryption, wrapped in encryption to the + // sender's outgoing viewing key. 80 bytes. + OvkWrappedKey []byte `protobuf:"bytes,4,opt,name=ovk_wrapped_key,json=ovkWrappedKey,proto3" json:"ovk_wrapped_key,omitempty"` +} + +func (m *OutputBody) Reset() { *m = OutputBody{} } +func (m *OutputBody) String() string { return proto.CompactTextString(m) } +func (*OutputBody) ProtoMessage() {} +func (*OutputBody) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{14} +} +func (m *OutputBody) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OutputBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OutputBody.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 *OutputBody) XXX_Merge(src proto.Message) { + xxx_messageInfo_OutputBody.Merge(m, src) +} +func (m *OutputBody) XXX_Size() int { + return m.Size() +} +func (m *OutputBody) XXX_DiscardUnknown() { + xxx_messageInfo_OutputBody.DiscardUnknown(m) +} + +var xxx_messageInfo_OutputBody proto.InternalMessageInfo + +func (m *OutputBody) GetNotePayload() *NotePayload { + if m != nil { + return m.NotePayload + } + return nil +} + +func (m *OutputBody) GetBalanceCommitment() *v1alpha1.BalanceCommitment { + if m != nil { + return m.BalanceCommitment + } + return nil +} + +func (m *OutputBody) GetWrappedMemoKey() []byte { + if m != nil { + return m.WrappedMemoKey + } + return nil +} + +func (m *OutputBody) GetOvkWrappedKey() []byte { + if m != nil { + return m.OvkWrappedKey + } + return nil +} + +type OutputView struct { + // Types that are valid to be assigned to OutputView: + // + // *OutputView_Visible_ + // *OutputView_Opaque_ + OutputView isOutputView_OutputView `protobuf_oneof:"output_view"` +} + +func (m *OutputView) Reset() { *m = OutputView{} } +func (m *OutputView) String() string { return proto.CompactTextString(m) } +func (*OutputView) ProtoMessage() {} +func (*OutputView) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{15} +} +func (m *OutputView) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OutputView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OutputView.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 *OutputView) XXX_Merge(src proto.Message) { + xxx_messageInfo_OutputView.Merge(m, src) +} +func (m *OutputView) XXX_Size() int { + return m.Size() +} +func (m *OutputView) XXX_DiscardUnknown() { + xxx_messageInfo_OutputView.DiscardUnknown(m) +} + +var xxx_messageInfo_OutputView proto.InternalMessageInfo + +type isOutputView_OutputView interface { + isOutputView_OutputView() + MarshalTo([]byte) (int, error) + Size() int +} + +type OutputView_Visible_ struct { + Visible *OutputView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` +} +type OutputView_Opaque_ struct { + Opaque *OutputView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +} + +func (*OutputView_Visible_) isOutputView_OutputView() {} +func (*OutputView_Opaque_) isOutputView_OutputView() {} + +func (m *OutputView) GetOutputView() isOutputView_OutputView { + if m != nil { + return m.OutputView + } + return nil +} + +func (m *OutputView) GetVisible() *OutputView_Visible { + if x, ok := m.GetOutputView().(*OutputView_Visible_); ok { + return x.Visible + } + return nil +} + +func (m *OutputView) GetOpaque() *OutputView_Opaque { + if x, ok := m.GetOutputView().(*OutputView_Opaque_); ok { + return x.Opaque + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*OutputView) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*OutputView_Visible_)(nil), + (*OutputView_Opaque_)(nil), + } +} + +type OutputView_Visible struct { + Output *Output `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"` + Note *NoteView `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` + PayloadKey *v1alpha11.PayloadKey `protobuf:"bytes,3,opt,name=payload_key,json=payloadKey,proto3" json:"payload_key,omitempty"` +} + +func (m *OutputView_Visible) Reset() { *m = OutputView_Visible{} } +func (m *OutputView_Visible) String() string { return proto.CompactTextString(m) } +func (*OutputView_Visible) ProtoMessage() {} +func (*OutputView_Visible) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{15, 0} +} +func (m *OutputView_Visible) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OutputView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OutputView_Visible.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 *OutputView_Visible) XXX_Merge(src proto.Message) { + xxx_messageInfo_OutputView_Visible.Merge(m, src) +} +func (m *OutputView_Visible) XXX_Size() int { + return m.Size() +} +func (m *OutputView_Visible) XXX_DiscardUnknown() { + xxx_messageInfo_OutputView_Visible.DiscardUnknown(m) +} + +var xxx_messageInfo_OutputView_Visible proto.InternalMessageInfo + +func (m *OutputView_Visible) GetOutput() *Output { + if m != nil { + return m.Output + } + return nil +} + +func (m *OutputView_Visible) GetNote() *NoteView { + if m != nil { + return m.Note + } + return nil +} + +func (m *OutputView_Visible) GetPayloadKey() *v1alpha11.PayloadKey { + if m != nil { + return m.PayloadKey + } + return nil +} + +type OutputView_Opaque struct { + Output *Output `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"` +} + +func (m *OutputView_Opaque) Reset() { *m = OutputView_Opaque{} } +func (m *OutputView_Opaque) String() string { return proto.CompactTextString(m) } +func (*OutputView_Opaque) ProtoMessage() {} +func (*OutputView_Opaque) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{15, 1} +} +func (m *OutputView_Opaque) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OutputView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OutputView_Opaque.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 *OutputView_Opaque) XXX_Merge(src proto.Message) { + xxx_messageInfo_OutputView_Opaque.Merge(m, src) +} +func (m *OutputView_Opaque) XXX_Size() int { + return m.Size() +} +func (m *OutputView_Opaque) XXX_DiscardUnknown() { + xxx_messageInfo_OutputView_Opaque.DiscardUnknown(m) +} + +var xxx_messageInfo_OutputView_Opaque proto.InternalMessageInfo + +func (m *OutputView_Opaque) GetOutput() *Output { + if m != nil { + return m.Output + } + return nil +} + +type OutputPlan struct { + // The value to send to this output. + Value *v1alpha1.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + // The destination address to send it to. + DestAddress *v1alpha11.Address `protobuf:"bytes,2,opt,name=dest_address,json=destAddress,proto3" json:"dest_address,omitempty"` + // The rseed to use for the new note. + Rseed []byte `protobuf:"bytes,3,opt,name=rseed,proto3" json:"rseed,omitempty"` + // The blinding factor to use for the value commitment. + ValueBlinding []byte `protobuf:"bytes,4,opt,name=value_blinding,json=valueBlinding,proto3" json:"value_blinding,omitempty"` + // The first blinding factor to use for the ZK output proof. + ProofBlindingR []byte `protobuf:"bytes,5,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` + // The second blinding factor to use for the ZK output proof. + ProofBlindingS []byte `protobuf:"bytes,6,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` +} + +func (m *OutputPlan) Reset() { *m = OutputPlan{} } +func (m *OutputPlan) String() string { return proto.CompactTextString(m) } +func (*OutputPlan) ProtoMessage() {} +func (*OutputPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{16} +} +func (m *OutputPlan) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OutputPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OutputPlan.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 *OutputPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_OutputPlan.Merge(m, src) +} +func (m *OutputPlan) XXX_Size() int { + return m.Size() +} +func (m *OutputPlan) XXX_DiscardUnknown() { + xxx_messageInfo_OutputPlan.DiscardUnknown(m) +} + +var xxx_messageInfo_OutputPlan proto.InternalMessageInfo + +func (m *OutputPlan) GetValue() *v1alpha1.Value { + if m != nil { + return m.Value + } + return nil +} + +func (m *OutputPlan) GetDestAddress() *v1alpha11.Address { + if m != nil { + return m.DestAddress + } + return nil +} + +func (m *OutputPlan) GetRseed() []byte { + if m != nil { + return m.Rseed + } + return nil +} + +func (m *OutputPlan) GetValueBlinding() []byte { + if m != nil { + return m.ValueBlinding + } + return nil +} + +func (m *OutputPlan) GetProofBlindingR() []byte { + if m != nil { + return m.ProofBlindingR + } + return nil +} + +func (m *OutputPlan) GetProofBlindingS() []byte { + if m != nil { + return m.ProofBlindingS + } + return nil +} + +// Requests information on an asset by asset id +type DenomMetadataByIdRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The asset id to request information on. + AssetId *v1alpha1.AssetId `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` +} + +func (m *DenomMetadataByIdRequest) Reset() { *m = DenomMetadataByIdRequest{} } +func (m *DenomMetadataByIdRequest) String() string { return proto.CompactTextString(m) } +func (*DenomMetadataByIdRequest) ProtoMessage() {} +func (*DenomMetadataByIdRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{17} +} +func (m *DenomMetadataByIdRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DenomMetadataByIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DenomMetadataByIdRequest.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 *DenomMetadataByIdRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DenomMetadataByIdRequest.Merge(m, src) +} +func (m *DenomMetadataByIdRequest) XXX_Size() int { + return m.Size() +} +func (m *DenomMetadataByIdRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DenomMetadataByIdRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DenomMetadataByIdRequest proto.InternalMessageInfo + +func (m *DenomMetadataByIdRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *DenomMetadataByIdRequest) GetAssetId() *v1alpha1.AssetId { + if m != nil { + return m.AssetId + } + return nil +} + +type DenomMetadataByIdResponse struct { + // If present, information on the requested asset. + // + // If the requested asset was unknown, this field will not be present. + DenomMetadata *v1alpha1.DenomMetadata `protobuf:"bytes,1,opt,name=denom_metadata,json=denomMetadata,proto3" json:"denom_metadata,omitempty"` +} + +func (m *DenomMetadataByIdResponse) Reset() { *m = DenomMetadataByIdResponse{} } +func (m *DenomMetadataByIdResponse) String() string { return proto.CompactTextString(m) } +func (*DenomMetadataByIdResponse) ProtoMessage() {} +func (*DenomMetadataByIdResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{18} +} +func (m *DenomMetadataByIdResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DenomMetadataByIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DenomMetadataByIdResponse.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 *DenomMetadataByIdResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DenomMetadataByIdResponse.Merge(m, src) +} +func (m *DenomMetadataByIdResponse) XXX_Size() int { + return m.Size() +} +func (m *DenomMetadataByIdResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DenomMetadataByIdResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DenomMetadataByIdResponse proto.InternalMessageInfo + +func (m *DenomMetadataByIdResponse) GetDenomMetadata() *v1alpha1.DenomMetadata { + if m != nil { + return m.DenomMetadata + } + return nil +} + +// Genesis data for the shielded pool component. +type GenesisContent struct { + // The allocations present at genesis + Allocations []*GenesisContent_Allocation `protobuf:"bytes,2,rep,name=allocations,proto3" json:"allocations,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{19} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.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 *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetAllocations() []*GenesisContent_Allocation { + if m != nil { + return m.Allocations + } + return nil +} + +type GenesisContent_Allocation struct { + Amount *v1alpha15.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` + Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"` + Address *v1alpha11.Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *GenesisContent_Allocation) Reset() { *m = GenesisContent_Allocation{} } +func (m *GenesisContent_Allocation) String() string { return proto.CompactTextString(m) } +func (*GenesisContent_Allocation) ProtoMessage() {} +func (*GenesisContent_Allocation) Descriptor() ([]byte, []int) { + return fileDescriptor_aa12195337df7d3c, []int{19, 0} +} +func (m *GenesisContent_Allocation) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent_Allocation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent_Allocation.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 *GenesisContent_Allocation) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent_Allocation.Merge(m, src) +} +func (m *GenesisContent_Allocation) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent_Allocation) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent_Allocation.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisContent_Allocation proto.InternalMessageInfo + +func (m *GenesisContent_Allocation) GetAmount() *v1alpha15.Amount { + if m != nil { + return m.Amount + } + return nil +} + +func (m *GenesisContent_Allocation) GetDenom() string { + if m != nil { + return m.Denom + } + return "" +} + +func (m *GenesisContent_Allocation) GetAddress() *v1alpha11.Address { + if m != nil { + return m.Address + } + return nil +} + +func init() { + proto.RegisterType((*Note)(nil), "penumbra.core.component.shielded_pool.v1alpha1.Note") + proto.RegisterType((*NoteView)(nil), "penumbra.core.component.shielded_pool.v1alpha1.NoteView") + proto.RegisterType((*NoteCiphertext)(nil), "penumbra.core.component.shielded_pool.v1alpha1.NoteCiphertext") + proto.RegisterType((*NotePayload)(nil), "penumbra.core.component.shielded_pool.v1alpha1.NotePayload") + proto.RegisterType((*ZKOutputProof)(nil), "penumbra.core.component.shielded_pool.v1alpha1.ZKOutputProof") + proto.RegisterType((*ZKSpendProof)(nil), "penumbra.core.component.shielded_pool.v1alpha1.ZKSpendProof") + proto.RegisterType((*ZKNullifierDerivationProof)(nil), "penumbra.core.component.shielded_pool.v1alpha1.ZKNullifierDerivationProof") + proto.RegisterType((*Spend)(nil), "penumbra.core.component.shielded_pool.v1alpha1.Spend") + proto.RegisterType((*EventSpend)(nil), "penumbra.core.component.shielded_pool.v1alpha1.EventSpend") + proto.RegisterType((*EventOutput)(nil), "penumbra.core.component.shielded_pool.v1alpha1.EventOutput") + proto.RegisterType((*SpendBody)(nil), "penumbra.core.component.shielded_pool.v1alpha1.SpendBody") + proto.RegisterType((*SpendView)(nil), "penumbra.core.component.shielded_pool.v1alpha1.SpendView") + proto.RegisterType((*SpendView_Visible)(nil), "penumbra.core.component.shielded_pool.v1alpha1.SpendView.Visible") + proto.RegisterType((*SpendView_Opaque)(nil), "penumbra.core.component.shielded_pool.v1alpha1.SpendView.Opaque") + proto.RegisterType((*SpendPlan)(nil), "penumbra.core.component.shielded_pool.v1alpha1.SpendPlan") + proto.RegisterType((*Output)(nil), "penumbra.core.component.shielded_pool.v1alpha1.Output") + proto.RegisterType((*OutputBody)(nil), "penumbra.core.component.shielded_pool.v1alpha1.OutputBody") + proto.RegisterType((*OutputView)(nil), "penumbra.core.component.shielded_pool.v1alpha1.OutputView") + proto.RegisterType((*OutputView_Visible)(nil), "penumbra.core.component.shielded_pool.v1alpha1.OutputView.Visible") + proto.RegisterType((*OutputView_Opaque)(nil), "penumbra.core.component.shielded_pool.v1alpha1.OutputView.Opaque") + proto.RegisterType((*OutputPlan)(nil), "penumbra.core.component.shielded_pool.v1alpha1.OutputPlan") + proto.RegisterType((*DenomMetadataByIdRequest)(nil), "penumbra.core.component.shielded_pool.v1alpha1.DenomMetadataByIdRequest") + proto.RegisterType((*DenomMetadataByIdResponse)(nil), "penumbra.core.component.shielded_pool.v1alpha1.DenomMetadataByIdResponse") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.shielded_pool.v1alpha1.GenesisContent") + proto.RegisterType((*GenesisContent_Allocation)(nil), "penumbra.core.component.shielded_pool.v1alpha1.GenesisContent.Allocation") +} + +func init() { + proto.RegisterFile("penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.proto", fileDescriptor_aa12195337df7d3c) +} + +var fileDescriptor_aa12195337df7d3c = []byte{ + // 1465 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x4b, 0x6f, 0xdb, 0x46, + 0x10, 0x36, 0xe5, 0xf7, 0x48, 0x56, 0x92, 0x45, 0x0f, 0x8e, 0x0e, 0x46, 0xa0, 0x3c, 0x6a, 0xa0, + 0x88, 0x84, 0x38, 0x6d, 0xd3, 0x28, 0x4d, 0x10, 0xcb, 0x29, 0x62, 0xc3, 0x89, 0xa3, 0xae, 0x10, + 0xb7, 0x70, 0xdc, 0x08, 0x2b, 0x71, 0x6d, 0x11, 0x22, 0xb9, 0x0c, 0xb9, 0x94, 0xab, 0xde, 0x7a, + 0xeb, 0xa1, 0x87, 0xde, 0x7a, 0x0b, 0xd0, 0x07, 0x8a, 0x22, 0x40, 0x7f, 0x40, 0xff, 0x41, 0xd1, + 0x53, 0xd0, 0x53, 0x8f, 0x85, 0x73, 0xeb, 0x2d, 0xff, 0xa0, 0xd8, 0x07, 0x29, 0x52, 0x7e, 0x34, + 0x92, 0x5d, 0xf4, 0x22, 0x70, 0x87, 0xdf, 0x7c, 0x33, 0x3b, 0x33, 0xfc, 0xb8, 0x14, 0x54, 0x3d, + 0xea, 0x86, 0x4e, 0xd3, 0x27, 0xe5, 0x16, 0xf3, 0x69, 0xb9, 0xc5, 0x1c, 0x8f, 0xb9, 0xd4, 0xe5, + 0xe5, 0xa0, 0x6d, 0x51, 0xdb, 0xa4, 0x66, 0xc3, 0x63, 0xcc, 0x2e, 0x77, 0xaf, 0x11, 0xdb, 0x6b, + 0x93, 0x6b, 0x69, 0x73, 0xc9, 0xf3, 0x19, 0x67, 0xa8, 0x14, 0x71, 0x94, 0x04, 0x47, 0x29, 0xe6, + 0x28, 0xa5, 0xc1, 0x11, 0x47, 0x61, 0x31, 0x1d, 0x93, 0x04, 0x01, 0xe5, 0xfd, 0x08, 0x72, 0xa9, + 0x98, 0x0b, 0xa5, 0x23, 0xb3, 0x6b, 0x25, 0x3c, 0x82, 0x56, 0x84, 0xbf, 0x92, 0xc6, 0x77, 0x68, + 0x2f, 0xe8, 0xc3, 0xc4, 0x4a, 0xe3, 0x2e, 0xa5, 0x71, 0x6e, 0xe8, 0xf4, 0x61, 0x6e, 0xe8, 0x68, + 0x54, 0xa5, 0x8f, 0xf2, 0x7b, 0x1e, 0x67, 0x65, 0x93, 0xb6, 0xc8, 0xce, 0xf5, 0x1b, 0x37, 0x1a, + 0xbe, 0x19, 0x90, 0xbe, 0x47, 0xca, 0x7c, 0x30, 0x13, 0xe5, 0xcb, 0x93, 0x19, 0xf3, 0x28, 0xe3, + 0xe2, 0xb7, 0x06, 0x4c, 0x6c, 0x30, 0x4e, 0xd1, 0x4d, 0x98, 0xec, 0x12, 0x3b, 0xa4, 0xf3, 0xc6, + 0x05, 0x63, 0x31, 0xbb, 0x74, 0x71, 0xa0, 0xa8, 0xaa, 0x2a, 0x11, 0x41, 0x69, 0x53, 0x40, 0xb1, + 0xf2, 0x40, 0x6f, 0xc1, 0xa4, 0x1f, 0x50, 0x6a, 0xce, 0x67, 0x2e, 0x18, 0x8b, 0x39, 0xac, 0x16, + 0xe8, 0x0e, 0x4c, 0x13, 0xd3, 0xf4, 0x69, 0x10, 0xcc, 0x8f, 0x4b, 0xca, 0x4b, 0x03, 0x94, 0xb2, + 0x1e, 0x31, 0xe3, 0xb2, 0xc2, 0xe2, 0xc8, 0xa9, 0xf8, 0x83, 0x01, 0x33, 0x22, 0xb3, 0x4d, 0x8b, + 0xee, 0xa1, 0xdb, 0xe9, 0xec, 0xde, 0x7e, 0x83, 0xec, 0x84, 0xdf, 0xf1, 0x19, 0x56, 0x07, 0x33, + 0x5c, 0x7c, 0x93, 0x0c, 0x25, 0x6f, 0x9c, 0xe5, 0x15, 0xc8, 0x8b, 0x24, 0x57, 0x2c, 0xaf, 0x4d, + 0x7d, 0x4e, 0x3f, 0xe7, 0x22, 0x96, 0xe5, 0xba, 0xd4, 0x97, 0xa9, 0xe6, 0xb0, 0x5a, 0x14, 0x5f, + 0x1b, 0x90, 0x15, 0xc0, 0x1a, 0xe9, 0xd9, 0x8c, 0x98, 0x68, 0x13, 0xce, 0xb8, 0x8c, 0xd3, 0x46, + 0x8b, 0x39, 0x8e, 0xc5, 0x1d, 0xea, 0x72, 0xbd, 0xb5, 0xab, 0x89, 0x1c, 0x64, 0xe7, 0x4a, 0xa2, + 0x59, 0x71, 0x12, 0x75, 0x4e, 0x38, 0x5d, 0x89, 0x9d, 0x70, 0x5e, 0xb0, 0xf4, 0xd7, 0xe8, 0x22, + 0xcc, 0x51, 0xaf, 0x4d, 0x1d, 0xea, 0x13, 0xbb, 0xd1, 0xa1, 0x3d, 0xbd, 0xe3, 0x5c, 0x6c, 0x5c, + 0xa7, 0x3d, 0x44, 0x21, 0x4f, 0x5d, 0xc9, 0x4e, 0xcd, 0x86, 0x20, 0xd0, 0xfb, 0xbf, 0x33, 0xe4, + 0x93, 0x54, 0x4a, 0x6f, 0x1d, 0xcf, 0xc5, 0xac, 0xe2, 0x46, 0xf1, 0x32, 0xcc, 0x6d, 0xad, 0x3f, + 0x0a, 0xb9, 0x17, 0xf2, 0x9a, 0xcf, 0xd8, 0xce, 0x11, 0xa5, 0xb9, 0x04, 0xb9, 0xad, 0xf5, 0xba, + 0x47, 0x5d, 0xf3, 0x38, 0xd4, 0x12, 0x14, 0xb6, 0xd6, 0x37, 0x42, 0xdb, 0xb6, 0x76, 0x2c, 0xea, + 0xdf, 0xa3, 0xbe, 0xd5, 0x25, 0xdc, 0x62, 0xee, 0x71, 0x3e, 0x5f, 0x66, 0x60, 0x52, 0x12, 0xa3, + 0x87, 0x30, 0xd1, 0x64, 0x66, 0x4f, 0xd7, 0xf8, 0xe6, 0xb0, 0xfb, 0x94, 0x24, 0x55, 0x66, 0xf6, + 0xb0, 0xa4, 0x41, 0x8f, 0x61, 0x86, 0x84, 0xbc, 0xdd, 0x08, 0xac, 0x5d, 0x59, 0xe0, 0xec, 0x52, + 0xe5, 0x40, 0xdb, 0xd2, 0x4f, 0x65, 0x9a, 0x6a, 0x39, 0xe4, 0xed, 0xba, 0xb5, 0xeb, 0x12, 0x1e, + 0xfa, 0x14, 0x4f, 0x13, 0xb5, 0x44, 0x18, 0x26, 0x3d, 0xb1, 0x1d, 0xdd, 0x8e, 0x0f, 0x87, 0x4d, + 0x33, 0x59, 0x46, 0xac, 0xa8, 0x8a, 0x4f, 0x00, 0x3e, 0xea, 0x52, 0x97, 0x47, 0x75, 0x98, 0x75, + 0xa3, 0x1a, 0xea, 0x62, 0x94, 0x8f, 0x8e, 0x92, 0x1c, 0xbc, 0xb8, 0xf4, 0xb8, 0xcf, 0x50, 0xa4, + 0x90, 0x95, 0xe4, 0xaa, 0xc9, 0xff, 0xd5, 0x50, 0x17, 0xbf, 0xca, 0xc0, 0x6c, 0xdc, 0x02, 0xf4, + 0x14, 0x50, 0x93, 0xd8, 0xc4, 0x6d, 0x1d, 0x12, 0xa8, 0x7c, 0xbc, 0x30, 0x54, 0x95, 0x5f, 0x22, + 0xd4, 0xb9, 0xe6, 0xa0, 0x29, 0x5d, 0xa3, 0xa9, 0x93, 0xd6, 0x08, 0x3d, 0x80, 0x8c, 0xdf, 0x99, + 0x9f, 0x38, 0xd0, 0xd1, 0x7f, 0x9f, 0x92, 0x4d, 0xea, 0x5b, 0x3b, 0x56, 0x4b, 0x8e, 0xf9, 0x3a, + 0xed, 0xe1, 0x8c, 0xdf, 0x29, 0xfe, 0x31, 0xae, 0x4b, 0x21, 0x65, 0xf1, 0x33, 0x98, 0xee, 0x5a, + 0x81, 0xd5, 0xb4, 0x23, 0x61, 0x5c, 0x1e, 0x69, 0xb2, 0x05, 0x57, 0x69, 0x53, 0x11, 0xad, 0x8e, + 0xe1, 0x88, 0x13, 0x6d, 0xc1, 0x14, 0xf3, 0xc8, 0xb3, 0x90, 0xea, 0x21, 0xbf, 0x3b, 0x3a, 0xfb, + 0x23, 0xc9, 0xb3, 0x3a, 0x86, 0x35, 0x63, 0xe1, 0x47, 0x03, 0xa6, 0x75, 0x48, 0xb4, 0x0e, 0x93, + 0x81, 0x40, 0xea, 0x4d, 0xbc, 0x37, 0x52, 0x18, 0xac, 0x38, 0xd0, 0x03, 0x98, 0x90, 0x92, 0xa6, + 0x52, 0xfe, 0x60, 0x14, 0x49, 0x93, 0x12, 0x2f, 0x59, 0x0a, 0x8f, 0x61, 0x4a, 0xa5, 0x7e, 0xaa, + 0x49, 0x56, 0x73, 0x00, 0xf2, 0xa2, 0xd1, 0xb5, 0xe8, 0x5e, 0xf1, 0xeb, 0x68, 0xbe, 0x6b, 0x36, + 0x71, 0xd1, 0xaa, 0xde, 0x80, 0x8a, 0xf3, 0xee, 0x28, 0x1b, 0x50, 0xc9, 0xa3, 0x02, 0xcc, 0x78, + 0x2c, 0xb0, 0xc4, 0xfc, 0xc8, 0x72, 0x4c, 0xe0, 0x78, 0x8d, 0x16, 0x00, 0x7c, 0xe2, 0x9a, 0xcc, + 0xb1, 0xbe, 0xa0, 0xbe, 0x14, 0x9c, 0x1c, 0x4e, 0x58, 0xd0, 0x65, 0xc8, 0xcb, 0x77, 0x67, 0xa3, + 0x69, 0x5b, 0xae, 0x69, 0xb9, 0xbb, 0x72, 0x84, 0x73, 0x78, 0x4e, 0x5a, 0xab, 0xda, 0x88, 0x16, + 0xe1, 0xac, 0xd4, 0x99, 0x18, 0xd6, 0xf0, 0xe7, 0x27, 0x25, 0x30, 0x2f, 0xed, 0x11, 0x10, 0x1f, + 0x82, 0x0c, 0xe4, 0xd3, 0x35, 0x88, 0xac, 0x17, 0x7f, 0x31, 0x60, 0x4a, 0x2b, 0xca, 0x46, 0x4a, + 0xb7, 0x2b, 0xc3, 0xd6, 0x42, 0xb1, 0x24, 0x84, 0xbb, 0x1e, 0x29, 0xac, 0x9a, 0x8e, 0xdb, 0xc3, + 0x2b, 0x6c, 0xe2, 0x7d, 0x16, 0x49, 0xec, 0xf3, 0x0c, 0x40, 0x3f, 0x12, 0x7a, 0x0a, 0x39, 0xa9, + 0x82, 0x9e, 0x7a, 0xd5, 0xeb, 0xdc, 0x6f, 0x8d, 0xd2, 0x47, 0x7d, 0x5a, 0xc0, 0x59, 0x37, 0x71, + 0x74, 0x38, 0x5c, 0xff, 0x32, 0xa7, 0xa6, 0x7f, 0x8b, 0x70, 0x76, 0xcf, 0x27, 0x9e, 0x47, 0xcd, + 0x86, 0x43, 0x1d, 0x26, 0x4f, 0x11, 0x6a, 0x3e, 0xf2, 0xda, 0xfe, 0x90, 0x3a, 0x4c, 0x9c, 0x23, + 0xae, 0xc0, 0x19, 0xd6, 0xed, 0x34, 0x22, 0xb4, 0x00, 0xea, 0x21, 0x61, 0xdd, 0xce, 0x27, 0xca, + 0xba, 0x4e, 0x7b, 0xc5, 0x9f, 0x26, 0xa2, 0x02, 0x49, 0xd5, 0x7a, 0x3a, 0xa8, 0x5a, 0xd5, 0xd1, + 0xfa, 0x7a, 0x94, 0x6c, 0x3d, 0x19, 0x90, 0xad, 0xe5, 0x13, 0xd0, 0x1f, 0xd0, 0xad, 0xd7, 0x09, + 0xdd, 0xda, 0x80, 0x29, 0x26, 0xa1, 0x7a, 0x1f, 0xef, 0x8f, 0x16, 0x08, 0x6b, 0x96, 0xd3, 0x95, + 0x2e, 0xb4, 0x0a, 0x59, 0x3d, 0x82, 0x71, 0x0b, 0x0f, 0x9e, 0x9c, 0xd3, 0x47, 0x5c, 0x3d, 0x62, + 0xe2, 0x65, 0x03, 0x5e, 0x7c, 0x5d, 0xf8, 0x34, 0x16, 0xc1, 0x53, 0xde, 0x71, 0x75, 0x0e, 0xb2, + 0xea, 0x4a, 0x09, 0xe1, 0x77, 0xf1, 0x93, 0x24, 0x95, 0xf0, 0x04, 0xdf, 0x24, 0xf7, 0x21, 0x67, + 0xd2, 0x80, 0x37, 0xa2, 0x03, 0x7e, 0x66, 0x88, 0x4f, 0x90, 0xac, 0xf0, 0xd4, 0x8b, 0xfe, 0xa7, + 0xc3, 0x78, 0xf2, 0xd3, 0xe1, 0x7f, 0x54, 0xc7, 0x3d, 0x98, 0xbf, 0x47, 0x5d, 0xe6, 0x3c, 0xa4, + 0x9c, 0x98, 0x84, 0x93, 0x6a, 0x6f, 0xcd, 0xc4, 0xf4, 0x59, 0x48, 0x03, 0x8e, 0xce, 0xc3, 0x4c, + 0xab, 0x4d, 0x2c, 0xb7, 0x61, 0x29, 0xd9, 0x99, 0xc5, 0xd3, 0x72, 0xbd, 0x66, 0xa2, 0xbb, 0x30, + 0x23, 0xeb, 0x25, 0x6e, 0xa9, 0x62, 0x5c, 0x3e, 0xbe, 0x9c, 0xcb, 0x62, 0xb9, 0x66, 0xe2, 0x69, + 0xa2, 0x2e, 0x8a, 0x0c, 0xce, 0x1f, 0x12, 0x38, 0xf0, 0x98, 0x1b, 0x50, 0x84, 0x21, 0x6f, 0x8a, + 0x9b, 0x0d, 0x47, 0xdf, 0xd5, 0x3d, 0x7b, 0xe7, 0xf8, 0x20, 0x29, 0x42, 0x3c, 0x67, 0x26, 0x97, + 0x42, 0x57, 0xf3, 0xf7, 0xa9, 0x4b, 0x03, 0x2b, 0x58, 0x61, 0x2e, 0x17, 0xda, 0xd4, 0x81, 0x2c, + 0xb1, 0x6d, 0xa6, 0xce, 0x44, 0xa2, 0xab, 0xe3, 0x8b, 0xd9, 0xa5, 0xb5, 0x61, 0x87, 0x30, 0x4d, + 0x5a, 0x5a, 0x8e, 0x19, 0x71, 0x92, 0xbd, 0xf0, 0xdc, 0x00, 0xe8, 0xdf, 0x43, 0x15, 0x98, 0x22, + 0x0e, 0x0b, 0xe3, 0xb3, 0x66, 0x71, 0x20, 0xac, 0xf8, 0x70, 0xef, 0x57, 0x4f, 0x22, 0xb1, 0xf6, + 0x10, 0x53, 0x24, 0xf7, 0x26, 0x4b, 0x3f, 0x8b, 0xd5, 0xe2, 0xa4, 0x9f, 0xc8, 0x4b, 0xbf, 0x1a, + 0x90, 0xfb, 0x38, 0xa4, 0x7e, 0xaf, 0x4e, 0xfd, 0xae, 0xd5, 0xa2, 0xe8, 0x67, 0x03, 0xce, 0x1d, + 0xe8, 0x11, 0x5a, 0x1d, 0xb6, 0x3e, 0x47, 0xcd, 0x57, 0x61, 0xed, 0x14, 0x98, 0xd4, 0xc0, 0x54, + 0x5f, 0x8c, 0xff, 0xb6, 0xbf, 0x60, 0xbc, 0xdc, 0x5f, 0x30, 0xfe, 0xda, 0x5f, 0x30, 0xbe, 0x79, + 0xb5, 0x30, 0xf6, 0xf2, 0xd5, 0xc2, 0xd8, 0x9f, 0xaf, 0x16, 0xc6, 0x60, 0xa9, 0xc5, 0x9c, 0x21, + 0x03, 0x55, 0xcf, 0xd5, 0xb5, 0xbd, 0xc6, 0x98, 0x5d, 0xf3, 0x19, 0x67, 0x35, 0x63, 0xcb, 0xdb, + 0xb5, 0x78, 0x3b, 0x6c, 0x0a, 0xef, 0x72, 0x8b, 0x05, 0x0e, 0x0b, 0xca, 0x3e, 0xb5, 0x49, 0x8f, + 0xfa, 0xe5, 0xee, 0x52, 0x7c, 0x29, 0x9f, 0x90, 0xa0, 0x3c, 0xdc, 0x1f, 0x51, 0xb7, 0x52, 0xe6, + 0xc8, 0xfa, 0x7d, 0x66, 0xa2, 0xb6, 0xb2, 0x52, 0x7f, 0x91, 0xb9, 0x5a, 0x8b, 0xd2, 0x5f, 0x11, + 0xe9, 0xaf, 0xc4, 0xe9, 0x27, 0xd3, 0x2c, 0x6d, 0x6a, 0xb7, 0xdf, 0xfb, 0xf8, 0x6d, 0x81, 0xdf, + 0x8e, 0xf1, 0xdb, 0x49, 0xfc, 0x76, 0x84, 0xdf, 0xcf, 0xdc, 0x1c, 0x0a, 0xbf, 0x7d, 0xbf, 0x56, + 0x8d, 0x9a, 0xf0, 0x77, 0xe6, 0x5a, 0xe4, 0x5b, 0xa9, 0x08, 0x67, 0xf1, 0xab, 0xbd, 0x2b, 0x95, + 0xa4, 0x7b, 0xa5, 0x12, 0xf9, 0x37, 0xa7, 0xe4, 0x9f, 0x45, 0xd7, 0xff, 0x09, 0x00, 0x00, 0xff, + 0xff, 0x31, 0x43, 0x7e, 0x0b, 0xae, 0x13, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + DenomMetadataById(ctx context.Context, in *DenomMetadataByIdRequest, opts ...grpc.CallOption) (*DenomMetadataByIdResponse, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) DenomMetadataById(ctx context.Context, in *DenomMetadataByIdRequest, opts ...grpc.CallOption) (*DenomMetadataByIdResponse, error) { + out := new(DenomMetadataByIdResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.shielded_pool.v1alpha1.QueryService/DenomMetadataById", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + DenomMetadataById(context.Context, *DenomMetadataByIdRequest) (*DenomMetadataByIdResponse, error) +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) DenomMetadataById(ctx context.Context, req *DenomMetadataByIdRequest) (*DenomMetadataByIdResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DenomMetadataById not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_DenomMetadataById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DenomMetadataByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).DenomMetadataById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.shielded_pool.v1alpha1.QueryService/DenomMetadataById", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).DenomMetadataById(ctx, req.(*DenomMetadataByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.shielded_pool.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "DenomMetadataById", + Handler: _QueryService_DenomMetadataById_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.proto", +} + +func (m *Note) 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 *Note) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Note) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Address != nil { + { + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if len(m.Rseed) > 0 { + i -= len(m.Rseed) + copy(dAtA[i:], m.Rseed) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Rseed))) + i-- + dAtA[i] = 0x12 + } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *NoteView) 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 *NoteView) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NoteView) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Address != nil { + { + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if len(m.Rseed) > 0 { + i -= len(m.Rseed) + copy(dAtA[i:], m.Rseed) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Rseed))) + i-- + dAtA[i] = 0x12 + } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *NoteCiphertext) 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 *NoteCiphertext) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NoteCiphertext) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *NotePayload) 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 *NotePayload) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NotePayload) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EncryptedNote != nil { + { + size, err := m.EncryptedNote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if len(m.EphemeralKey) > 0 { + i -= len(m.EphemeralKey) + copy(dAtA[i:], m.EphemeralKey) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.EphemeralKey))) + i-- + dAtA[i] = 0x12 + } + if m.NoteCommitment != nil { + { + size, err := m.NoteCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ZKOutputProof) 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 *ZKOutputProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ZKOutputProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ZKSpendProof) 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 *ZKSpendProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ZKSpendProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ZKNullifierDerivationProof) 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 *ZKNullifierDerivationProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ZKNullifierDerivationProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Spend) 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 *Spend) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Proof != nil { + { + size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.AuthSig != nil { + { + size, err := m.AuthSig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Body != nil { + { + size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventSpend) 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 *EventSpend) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Nullifier != nil { + { + size, err := m.Nullifier.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventOutput) 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 *EventOutput) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NoteCommitment != nil { + { + size, err := m.NoteCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SpendBody) 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 *SpendBody) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Nullifier != nil { + { + size, err := m.Nullifier.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.Rk != nil { + { + size, err := m.Rk.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.BalanceCommitment != nil { + { + size, err := m.BalanceCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SpendView) 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 *SpendView) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendView) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SpendView != nil { + { + size := m.SpendView.Size() + i -= size + if _, err := m.SpendView.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *SpendView_Visible_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Visible != nil { + { + size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *SpendView_Opaque_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Opaque != nil { + { + size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *SpendView_Visible) 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 *SpendView_Visible) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Note != nil { + { + size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Spend != nil { + { + size, err := m.Spend.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SpendView_Opaque) 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 *SpendView_Opaque) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Spend != nil { + { + size, err := m.Spend.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SpendPlan) 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 *SpendPlan) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ProofBlindingS) > 0 { + i -= len(m.ProofBlindingS) + copy(dAtA[i:], m.ProofBlindingS) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.ProofBlindingS))) + i-- + dAtA[i] = 0x32 + } + if len(m.ProofBlindingR) > 0 { + i -= len(m.ProofBlindingR) + copy(dAtA[i:], m.ProofBlindingR) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.ProofBlindingR))) + i-- + dAtA[i] = 0x2a + } + if len(m.ValueBlinding) > 0 { + i -= len(m.ValueBlinding) + copy(dAtA[i:], m.ValueBlinding) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.ValueBlinding))) + i-- + dAtA[i] = 0x22 + } + if len(m.Randomizer) > 0 { + i -= len(m.Randomizer) + copy(dAtA[i:], m.Randomizer) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Randomizer))) + i-- + dAtA[i] = 0x1a + } + if m.Position != 0 { + i = encodeVarintShieldedPool(dAtA, i, uint64(m.Position)) + i-- + dAtA[i] = 0x10 + } + if m.Note != nil { + { + size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Output) 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 *Output) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Output) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Proof != nil { + { + size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Body != nil { + { + size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *OutputBody) 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 *OutputBody) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OutputBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.OvkWrappedKey) > 0 { + i -= len(m.OvkWrappedKey) + copy(dAtA[i:], m.OvkWrappedKey) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.OvkWrappedKey))) + i-- + dAtA[i] = 0x22 + } + if len(m.WrappedMemoKey) > 0 { + i -= len(m.WrappedMemoKey) + copy(dAtA[i:], m.WrappedMemoKey) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.WrappedMemoKey))) + i-- + dAtA[i] = 0x1a + } + if m.BalanceCommitment != nil { + { + size, err := m.BalanceCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.NotePayload != nil { + { + size, err := m.NotePayload.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *OutputView) 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 *OutputView) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OutputView) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.OutputView != nil { + { + size := m.OutputView.Size() + i -= size + if _, err := m.OutputView.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *OutputView_Visible_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OutputView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Visible != nil { + { + size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *OutputView_Opaque_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OutputView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Opaque != nil { + { + size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *OutputView_Visible) 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 *OutputView_Visible) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OutputView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.PayloadKey != nil { + { + size, err := m.PayloadKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Note != nil { + { + size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Output != nil { + { + size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *OutputView_Opaque) 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 *OutputView_Opaque) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OutputView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Output != nil { + { + size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *OutputPlan) 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 *OutputPlan) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OutputPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ProofBlindingS) > 0 { + i -= len(m.ProofBlindingS) + copy(dAtA[i:], m.ProofBlindingS) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.ProofBlindingS))) + i-- + dAtA[i] = 0x32 + } + if len(m.ProofBlindingR) > 0 { + i -= len(m.ProofBlindingR) + copy(dAtA[i:], m.ProofBlindingR) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.ProofBlindingR))) + i-- + dAtA[i] = 0x2a + } + if len(m.ValueBlinding) > 0 { + i -= len(m.ValueBlinding) + copy(dAtA[i:], m.ValueBlinding) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.ValueBlinding))) + i-- + dAtA[i] = 0x22 + } + if len(m.Rseed) > 0 { + i -= len(m.Rseed) + copy(dAtA[i:], m.Rseed) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Rseed))) + i-- + dAtA[i] = 0x1a + } + if m.DestAddress != nil { + { + size, err := m.DestAddress.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DenomMetadataByIdRequest) 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 *DenomMetadataByIdRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DenomMetadataByIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AssetId != nil { + { + size, err := m.AssetId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DenomMetadataByIdResponse) 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 *DenomMetadataByIdResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DenomMetadataByIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DenomMetadata != nil { + { + size, err := m.DenomMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Allocations) > 0 { + for iNdEx := len(m.Allocations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Allocations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + return len(dAtA) - i, nil +} + +func (m *GenesisContent_Allocation) 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 *GenesisContent_Allocation) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent_Allocation) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Address != nil { + { + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0x12 + } + if m.Amount != nil { + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintShieldedPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintShieldedPool(dAtA []byte, offset int, v uint64) int { + offset -= sovShieldedPool(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Note) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.Rseed) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Address != nil { + l = m.Address.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *NoteView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.Rseed) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Address != nil { + l = m.Address.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *NoteCiphertext) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *NotePayload) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NoteCommitment != nil { + l = m.NoteCommitment.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.EphemeralKey) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.EncryptedNote != nil { + l = m.EncryptedNote.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *ZKOutputProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *ZKSpendProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *ZKNullifierDerivationProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *Spend) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Body != nil { + l = m.Body.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.AuthSig != nil { + l = m.AuthSig.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Proof != nil { + l = m.Proof.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *EventSpend) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Nullifier != nil { + l = m.Nullifier.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *EventOutput) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NoteCommitment != nil { + l = m.NoteCommitment.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *SpendBody) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BalanceCommitment != nil { + l = m.BalanceCommitment.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Rk != nil { + l = m.Rk.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Nullifier != nil { + l = m.Nullifier.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *SpendView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SpendView != nil { + n += m.SpendView.Size() + } + return n +} + +func (m *SpendView_Visible_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Visible != nil { + l = m.Visible.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} +func (m *SpendView_Opaque_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Opaque != nil { + l = m.Opaque.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} +func (m *SpendView_Visible) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Spend != nil { + l = m.Spend.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Note != nil { + l = m.Note.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *SpendView_Opaque) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Spend != nil { + l = m.Spend.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *SpendPlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Note != nil { + l = m.Note.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Position != 0 { + n += 1 + sovShieldedPool(uint64(m.Position)) + } + l = len(m.Randomizer) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.ValueBlinding) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.ProofBlindingR) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.ProofBlindingS) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *Output) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Body != nil { + l = m.Body.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Proof != nil { + l = m.Proof.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *OutputBody) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NotePayload != nil { + l = m.NotePayload.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.BalanceCommitment != nil { + l = m.BalanceCommitment.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.WrappedMemoKey) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.OvkWrappedKey) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *OutputView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.OutputView != nil { + n += m.OutputView.Size() + } + return n +} + +func (m *OutputView_Visible_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Visible != nil { + l = m.Visible.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} +func (m *OutputView_Opaque_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Opaque != nil { + l = m.Opaque.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} +func (m *OutputView_Visible) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Output != nil { + l = m.Output.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Note != nil { + l = m.Note.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.PayloadKey != nil { + l = m.PayloadKey.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *OutputView_Opaque) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Output != nil { + l = m.Output.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *OutputPlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.DestAddress != nil { + l = m.DestAddress.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.Rseed) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.ValueBlinding) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.ProofBlindingR) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.ProofBlindingS) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *DenomMetadataByIdRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.AssetId != nil { + l = m.AssetId.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *DenomMetadataByIdResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DenomMetadata != nil { + l = m.DenomMetadata.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Allocations) > 0 { + for _, e := range m.Allocations { + l = e.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + } + return n +} + +func (m *GenesisContent_Allocation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Amount != nil { + l = m.Amount.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovShieldedPool(uint64(l)) + } + if m.Address != nil { + l = m.Address.Size() + n += 1 + l + sovShieldedPool(uint64(l)) + } + return n +} + +func sovShieldedPool(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozShieldedPool(x uint64) (n int) { + return sovShieldedPool(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Note) 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 ErrIntOverflowShieldedPool + } + 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: Note: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Note: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &v1alpha1.Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) + if m.Rseed == nil { + m.Rseed = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &v1alpha11.Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NoteView) 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 ErrIntOverflowShieldedPool + } + 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: NoteView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NoteView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &v1alpha1.ValueView{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) + if m.Rseed == nil { + m.Rseed = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &v1alpha11.AddressView{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NoteCiphertext) 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 ErrIntOverflowShieldedPool + } + 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: NoteCiphertext: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NoteCiphertext: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NotePayload) 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 ErrIntOverflowShieldedPool + } + 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: NotePayload: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NotePayload: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NoteCommitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NoteCommitment == nil { + m.NoteCommitment = &v1alpha12.StateCommitment{} + } + if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EphemeralKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EphemeralKey = append(m.EphemeralKey[:0], dAtA[iNdEx:postIndex]...) + if m.EphemeralKey == nil { + m.EphemeralKey = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EncryptedNote", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EncryptedNote == nil { + m.EncryptedNote = &NoteCiphertext{} + } + if err := m.EncryptedNote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ZKOutputProof) 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 ErrIntOverflowShieldedPool + } + 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: ZKOutputProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZKOutputProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ZKSpendProof) 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 ErrIntOverflowShieldedPool + } + 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: ZKSpendProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZKSpendProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ZKNullifierDerivationProof) 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 ErrIntOverflowShieldedPool + } + 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: ZKNullifierDerivationProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZKNullifierDerivationProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Spend) 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 ErrIntOverflowShieldedPool + } + 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: Spend: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Spend: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = &SpendBody{} + } + if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuthSig == nil { + m.AuthSig = &v1alpha13.SpendAuthSignature{} + } + if err := m.AuthSig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proof == nil { + m.Proof = &ZKSpendProof{} + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventSpend) 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 ErrIntOverflowShieldedPool + } + 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: EventSpend: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventSpend: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nullifier == nil { + m.Nullifier = &v1alpha14.Nullifier{} + } + if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventOutput) 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 ErrIntOverflowShieldedPool + } + 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: EventOutput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventOutput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NoteCommitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NoteCommitment == nil { + m.NoteCommitment = &v1alpha12.StateCommitment{} + } + if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpendBody) 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 ErrIntOverflowShieldedPool + } + 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: SpendBody: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpendBody: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BalanceCommitment == nil { + m.BalanceCommitment = &v1alpha1.BalanceCommitment{} + } + if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rk", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Rk == nil { + m.Rk = &v1alpha13.SpendVerificationKey{} + } + if err := m.Rk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nullifier == nil { + m.Nullifier = &v1alpha14.Nullifier{} + } + if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpendView) 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 ErrIntOverflowShieldedPool + } + 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: SpendView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpendView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &SpendView_Visible{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.SpendView = &SpendView_Visible_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &SpendView_Opaque{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.SpendView = &SpendView_Opaque_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpendView_Visible) 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 ErrIntOverflowShieldedPool + } + 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: Visible: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Spend == nil { + m.Spend = &Spend{} + } + if err := m.Spend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Note == nil { + m.Note = &NoteView{} + } + if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpendView_Opaque) 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 ErrIntOverflowShieldedPool + } + 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: Opaque: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Spend == nil { + m.Spend = &Spend{} + } + if err := m.Spend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpendPlan) 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 ErrIntOverflowShieldedPool + } + 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: SpendPlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpendPlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Note == nil { + m.Note = &Note{} + } + if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) + } + m.Position = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Position |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Randomizer", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Randomizer = append(m.Randomizer[:0], dAtA[iNdEx:postIndex]...) + if m.Randomizer == nil { + m.Randomizer = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValueBlinding", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValueBlinding = append(m.ValueBlinding[:0], dAtA[iNdEx:postIndex]...) + if m.ValueBlinding == nil { + m.ValueBlinding = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingR == nil { + m.ProofBlindingR = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingS == nil { + m.ProofBlindingS = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Output) 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 ErrIntOverflowShieldedPool + } + 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: Output: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Output: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = &OutputBody{} + } + if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proof == nil { + m.Proof = &ZKOutputProof{} + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OutputBody) 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 ErrIntOverflowShieldedPool + } + 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: OutputBody: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OutputBody: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotePayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NotePayload == nil { + m.NotePayload = &NotePayload{} + } + if err := m.NotePayload.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BalanceCommitment == nil { + m.BalanceCommitment = &v1alpha1.BalanceCommitment{} + } + if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WrappedMemoKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WrappedMemoKey = append(m.WrappedMemoKey[:0], dAtA[iNdEx:postIndex]...) + if m.WrappedMemoKey == nil { + m.WrappedMemoKey = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OvkWrappedKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OvkWrappedKey = append(m.OvkWrappedKey[:0], dAtA[iNdEx:postIndex]...) + if m.OvkWrappedKey == nil { + m.OvkWrappedKey = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OutputView) 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 ErrIntOverflowShieldedPool + } + 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: OutputView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OutputView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &OutputView_Visible{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.OutputView = &OutputView_Visible_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &OutputView_Opaque{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.OutputView = &OutputView_Opaque_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OutputView_Visible) 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 ErrIntOverflowShieldedPool + } + 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: Visible: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output == nil { + m.Output = &Output{} + } + if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Note == nil { + m.Note = &NoteView{} + } + if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PayloadKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PayloadKey == nil { + m.PayloadKey = &v1alpha11.PayloadKey{} + } + if err := m.PayloadKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OutputView_Opaque) 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 ErrIntOverflowShieldedPool + } + 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: Opaque: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output == nil { + m.Output = &Output{} + } + if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OutputPlan) 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 ErrIntOverflowShieldedPool + } + 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: OutputPlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OutputPlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &v1alpha1.Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DestAddress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DestAddress == nil { + m.DestAddress = &v1alpha11.Address{} + } + if err := m.DestAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) + if m.Rseed == nil { + m.Rseed = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValueBlinding", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValueBlinding = append(m.ValueBlinding[:0], dAtA[iNdEx:postIndex]...) + if m.ValueBlinding == nil { + m.ValueBlinding = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingR == nil { + m.ProofBlindingR = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingS == nil { + m.ProofBlindingS = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DenomMetadataByIdRequest) 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 ErrIntOverflowShieldedPool + } + 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: DenomMetadataByIdRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DenomMetadataByIdRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + 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 ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AssetId == nil { + m.AssetId = &v1alpha1.AssetId{} + } + if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DenomMetadataByIdResponse) 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 ErrIntOverflowShieldedPool + } + 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: DenomMetadataByIdResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DenomMetadataByIdResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DenomMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DenomMetadata == nil { + m.DenomMetadata = &v1alpha1.DenomMetadata{} + } + if err := m.DenomMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent) 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 ErrIntOverflowShieldedPool + } + 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: GenesisContent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Allocations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Allocations = append(m.Allocations, &GenesisContent_Allocation{}) + if err := m.Allocations[len(m.Allocations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisContent_Allocation) 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 ErrIntOverflowShieldedPool + } + 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: Allocation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Allocation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Amount == nil { + m.Amount = &v1alpha15.Amount{} + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + 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 ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowShieldedPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthShieldedPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthShieldedPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &v1alpha11.Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipShieldedPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthShieldedPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipShieldedPool(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, ErrIntOverflowShieldedPool + } + 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, ErrIntOverflowShieldedPool + } + 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, ErrIntOverflowShieldedPool + } + 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, ErrInvalidLengthShieldedPool + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupShieldedPool + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthShieldedPool + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthShieldedPool = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowShieldedPool = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupShieldedPool = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/stake/v1alpha1/stake.pb.go b/relayer/chains/penumbra/core/component/stake/v1alpha1/stake.pb.go similarity index 59% rename from relayer/chains/penumbra/core/stake/v1alpha1/stake.pb.go rename to relayer/chains/penumbra/core/component/stake/v1alpha1/stake.pb.go index 690e79f23..1150e0781 100644 --- a/relayer/chains/penumbra/core/stake/v1alpha1/stake.pb.go +++ b/relayer/chains/penumbra/core/component/stake/v1alpha1/stake.pb.go @@ -1,12 +1,19 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: penumbra/core/stake/v1alpha1/stake.proto +// source: penumbra/core/component/stake/v1alpha1/stake.proto package stakev1alpha1 import ( + context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" proto "github.com/cosmos/gogoproto/proto" - v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" + v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" @@ -51,7 +58,7 @@ func (x BondingState_BondingStateEnum) String() string { } func (BondingState_BondingStateEnum) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{6, 0} + return fileDescriptor_b49c30b9d712baf6, []int{7, 0} } type ValidatorState_ValidatorStateEnum int32 @@ -88,7 +95,52 @@ func (x ValidatorState_ValidatorStateEnum) String() string { } func (ValidatorState_ValidatorStateEnum) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{7, 0} + return fileDescriptor_b49c30b9d712baf6, []int{8, 0} +} + +// A Penumbra ZK undelegate claim proof. +type ZKUndelegateClaimProof struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *ZKUndelegateClaimProof) Reset() { *m = ZKUndelegateClaimProof{} } +func (m *ZKUndelegateClaimProof) String() string { return proto.CompactTextString(m) } +func (*ZKUndelegateClaimProof) ProtoMessage() {} +func (*ZKUndelegateClaimProof) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{0} +} +func (m *ZKUndelegateClaimProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZKUndelegateClaimProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZKUndelegateClaimProof.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 *ZKUndelegateClaimProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZKUndelegateClaimProof.Merge(m, src) +} +func (m *ZKUndelegateClaimProof) XXX_Size() int { + return m.Size() +} +func (m *ZKUndelegateClaimProof) XXX_DiscardUnknown() { + xxx_messageInfo_ZKUndelegateClaimProof.DiscardUnknown(m) +} + +var xxx_messageInfo_ZKUndelegateClaimProof proto.InternalMessageInfo + +func (m *ZKUndelegateClaimProof) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil } // Describes a validator's configuration data. @@ -121,7 +173,7 @@ func (m *Validator) Reset() { *m = Validator{} } func (m *Validator) String() string { return proto.CompactTextString(m) } func (*Validator) ProtoMessage() {} func (*Validator) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{0} + return fileDescriptor_b49c30b9d712baf6, []int{1} } func (m *Validator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -222,7 +274,7 @@ func (m *ValidatorList) Reset() { *m = ValidatorList{} } func (m *ValidatorList) String() string { return proto.CompactTextString(m) } func (*ValidatorList) ProtoMessage() {} func (*ValidatorList) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{1} + return fileDescriptor_b49c30b9d712baf6, []int{2} } func (m *ValidatorList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -263,8 +315,9 @@ type FundingStream struct { // The recipient of the funding stream. // // Types that are valid to be assigned to Recipient: + // // *FundingStream_ToAddress_ - // *FundingStream_ToDao_ + // *FundingStream_ToCommunityPool_ Recipient isFundingStream_Recipient `protobuf_oneof:"recipient"` } @@ -272,7 +325,7 @@ func (m *FundingStream) Reset() { *m = FundingStream{} } func (m *FundingStream) String() string { return proto.CompactTextString(m) } func (*FundingStream) ProtoMessage() {} func (*FundingStream) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{2} + return fileDescriptor_b49c30b9d712baf6, []int{3} } func (m *FundingStream) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -310,12 +363,12 @@ type isFundingStream_Recipient interface { type FundingStream_ToAddress_ struct { ToAddress *FundingStream_ToAddress `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3,oneof" json:"to_address,omitempty"` } -type FundingStream_ToDao_ struct { - ToDao *FundingStream_ToDao `protobuf:"bytes,2,opt,name=to_dao,json=toDao,proto3,oneof" json:"to_dao,omitempty"` +type FundingStream_ToCommunityPool_ struct { + ToCommunityPool *FundingStream_ToCommunityPool `protobuf:"bytes,2,opt,name=to_community_pool,json=toCommunityPool,proto3,oneof" json:"to_community_pool,omitempty"` } -func (*FundingStream_ToAddress_) isFundingStream_Recipient() {} -func (*FundingStream_ToDao_) isFundingStream_Recipient() {} +func (*FundingStream_ToAddress_) isFundingStream_Recipient() {} +func (*FundingStream_ToCommunityPool_) isFundingStream_Recipient() {} func (m *FundingStream) GetRecipient() isFundingStream_Recipient { if m != nil { @@ -331,9 +384,9 @@ func (m *FundingStream) GetToAddress() *FundingStream_ToAddress { return nil } -func (m *FundingStream) GetToDao() *FundingStream_ToDao { - if x, ok := m.GetRecipient().(*FundingStream_ToDao_); ok { - return x.ToDao +func (m *FundingStream) GetToCommunityPool() *FundingStream_ToCommunityPool { + if x, ok := m.GetRecipient().(*FundingStream_ToCommunityPool_); ok { + return x.ToCommunityPool } return nil } @@ -342,7 +395,7 @@ func (m *FundingStream) GetToDao() *FundingStream_ToDao { func (*FundingStream) XXX_OneofWrappers() []interface{} { return []interface{}{ (*FundingStream_ToAddress_)(nil), - (*FundingStream_ToDao_)(nil), + (*FundingStream_ToCommunityPool_)(nil), } } @@ -358,7 +411,7 @@ func (m *FundingStream_ToAddress) Reset() { *m = FundingStream_ToAddress func (m *FundingStream_ToAddress) String() string { return proto.CompactTextString(m) } func (*FundingStream_ToAddress) ProtoMessage() {} func (*FundingStream_ToAddress) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{2, 0} + return fileDescriptor_b49c30b9d712baf6, []int{3, 0} } func (m *FundingStream_ToAddress) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -401,24 +454,24 @@ func (m *FundingStream_ToAddress) GetRateBps() uint32 { return 0 } -type FundingStream_ToDao struct { +type FundingStream_ToCommunityPool struct { // The portion of the staking reward for the entire delegation pool // allocated to this funding stream, specified in basis points. RateBps uint32 `protobuf:"varint,2,opt,name=rate_bps,json=rateBps,proto3" json:"rate_bps,omitempty"` } -func (m *FundingStream_ToDao) Reset() { *m = FundingStream_ToDao{} } -func (m *FundingStream_ToDao) String() string { return proto.CompactTextString(m) } -func (*FundingStream_ToDao) ProtoMessage() {} -func (*FundingStream_ToDao) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{2, 1} +func (m *FundingStream_ToCommunityPool) Reset() { *m = FundingStream_ToCommunityPool{} } +func (m *FundingStream_ToCommunityPool) String() string { return proto.CompactTextString(m) } +func (*FundingStream_ToCommunityPool) ProtoMessage() {} +func (*FundingStream_ToCommunityPool) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{3, 1} } -func (m *FundingStream_ToDao) XXX_Unmarshal(b []byte) error { +func (m *FundingStream_ToCommunityPool) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *FundingStream_ToDao) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *FundingStream_ToCommunityPool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_FundingStream_ToDao.Marshal(b, m, deterministic) + return xxx_messageInfo_FundingStream_ToCommunityPool.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -428,19 +481,19 @@ func (m *FundingStream_ToDao) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (m *FundingStream_ToDao) XXX_Merge(src proto.Message) { - xxx_messageInfo_FundingStream_ToDao.Merge(m, src) +func (m *FundingStream_ToCommunityPool) XXX_Merge(src proto.Message) { + xxx_messageInfo_FundingStream_ToCommunityPool.Merge(m, src) } -func (m *FundingStream_ToDao) XXX_Size() int { +func (m *FundingStream_ToCommunityPool) XXX_Size() int { return m.Size() } -func (m *FundingStream_ToDao) XXX_DiscardUnknown() { - xxx_messageInfo_FundingStream_ToDao.DiscardUnknown(m) +func (m *FundingStream_ToCommunityPool) XXX_DiscardUnknown() { + xxx_messageInfo_FundingStream_ToCommunityPool.DiscardUnknown(m) } -var xxx_messageInfo_FundingStream_ToDao proto.InternalMessageInfo +var xxx_messageInfo_FundingStream_ToCommunityPool proto.InternalMessageInfo -func (m *FundingStream_ToDao) GetRateBps() uint32 { +func (m *FundingStream_ToCommunityPool) GetRateBps() uint32 { if m != nil { return m.RateBps } @@ -459,7 +512,7 @@ func (m *RateData) Reset() { *m = RateData{} } func (m *RateData) String() string { return proto.CompactTextString(m) } func (*RateData) ProtoMessage() {} func (*RateData) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{3} + return fileDescriptor_b49c30b9d712baf6, []int{4} } func (m *RateData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -527,7 +580,7 @@ func (m *BaseRateData) Reset() { *m = BaseRateData{} } func (m *BaseRateData) String() string { return proto.CompactTextString(m) } func (*BaseRateData) ProtoMessage() {} func (*BaseRateData) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{4} + return fileDescriptor_b49c30b9d712baf6, []int{5} } func (m *BaseRateData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -589,7 +642,7 @@ func (m *ValidatorStatus) Reset() { *m = ValidatorStatus{} } func (m *ValidatorStatus) String() string { return proto.CompactTextString(m) } func (*ValidatorStatus) ProtoMessage() {} func (*ValidatorStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{5} + return fileDescriptor_b49c30b9d712baf6, []int{6} } func (m *ValidatorStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -648,17 +701,15 @@ func (m *ValidatorStatus) GetBondingState() *BondingState { // Describes the unbonding state of a validator's stake pool. type BondingState struct { - State BondingState_BondingStateEnum `protobuf:"varint,1,opt,name=state,proto3,enum=penumbra.core.stake.v1alpha1.BondingState_BondingStateEnum" json:"state,omitempty"` - // Types that are valid to be assigned to XUnbondingEpoch: - // *BondingState_UnbondingEpoch - XUnbondingEpoch isBondingState_XUnbondingEpoch `protobuf_oneof:"_unbonding_epoch"` + State BondingState_BondingStateEnum `protobuf:"varint,1,opt,name=state,proto3,enum=penumbra.core.component.stake.v1alpha1.BondingState_BondingStateEnum" json:"state,omitempty"` + UnbondingEpoch uint64 `protobuf:"varint,2,opt,name=unbonding_epoch,json=unbondingEpoch,proto3" json:"unbonding_epoch,omitempty"` } func (m *BondingState) Reset() { *m = BondingState{} } func (m *BondingState) String() string { return proto.CompactTextString(m) } func (*BondingState) ProtoMessage() {} func (*BondingState) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{6} + return fileDescriptor_b49c30b9d712baf6, []int{7} } func (m *BondingState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -687,25 +738,6 @@ func (m *BondingState) XXX_DiscardUnknown() { var xxx_messageInfo_BondingState proto.InternalMessageInfo -type isBondingState_XUnbondingEpoch interface { - isBondingState_XUnbondingEpoch() - MarshalTo([]byte) (int, error) - Size() int -} - -type BondingState_UnbondingEpoch struct { - UnbondingEpoch uint64 `protobuf:"varint,2,opt,name=unbonding_epoch,json=unbondingEpoch,proto3,oneof" json:"unbonding_epoch,omitempty"` -} - -func (*BondingState_UnbondingEpoch) isBondingState_XUnbondingEpoch() {} - -func (m *BondingState) GetXUnbondingEpoch() isBondingState_XUnbondingEpoch { - if m != nil { - return m.XUnbondingEpoch - } - return nil -} - func (m *BondingState) GetState() BondingState_BondingStateEnum { if m != nil { return m.State @@ -714,29 +746,22 @@ func (m *BondingState) GetState() BondingState_BondingStateEnum { } func (m *BondingState) GetUnbondingEpoch() uint64 { - if x, ok := m.GetXUnbondingEpoch().(*BondingState_UnbondingEpoch); ok { - return x.UnbondingEpoch + if m != nil { + return m.UnbondingEpoch } return 0 } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*BondingState) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*BondingState_UnbondingEpoch)(nil), - } -} - // Describes the state of a validator type ValidatorState struct { - State ValidatorState_ValidatorStateEnum `protobuf:"varint,1,opt,name=state,proto3,enum=penumbra.core.stake.v1alpha1.ValidatorState_ValidatorStateEnum" json:"state,omitempty"` + State ValidatorState_ValidatorStateEnum `protobuf:"varint,1,opt,name=state,proto3,enum=penumbra.core.component.stake.v1alpha1.ValidatorState_ValidatorStateEnum" json:"state,omitempty"` } func (m *ValidatorState) Reset() { *m = ValidatorState{} } func (m *ValidatorState) String() string { return proto.CompactTextString(m) } func (*ValidatorState) ProtoMessage() {} func (*ValidatorState) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{7} + return fileDescriptor_b49c30b9d712baf6, []int{8} } func (m *ValidatorState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -783,7 +808,7 @@ func (m *ValidatorInfo) Reset() { *m = ValidatorInfo{} } func (m *ValidatorInfo) String() string { return proto.CompactTextString(m) } func (*ValidatorInfo) ProtoMessage() {} func (*ValidatorInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{8} + return fileDescriptor_b49c30b9d712baf6, []int{9} } func (m *ValidatorInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -845,7 +870,7 @@ func (m *ValidatorDefinition) Reset() { *m = ValidatorDefinition{} } func (m *ValidatorDefinition) String() string { return proto.CompactTextString(m) } func (*ValidatorDefinition) ProtoMessage() {} func (*ValidatorDefinition) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{9} + return fileDescriptor_b49c30b9d712baf6, []int{10} } func (m *ValidatorDefinition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -897,20 +922,20 @@ type Delegate struct { EpochIndex uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"` // The delegation amount, in units of unbonded stake. // TODO: use flow aggregation to hide this, replacing it with bytes amount_ciphertext; - UnbondedAmount *v1alpha1.Amount `protobuf:"bytes,3,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"` + UnbondedAmount *v1alpha11.Amount `protobuf:"bytes,3,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"` // The amount of delegation tokens produced by this action. // // This is implied by the validator's exchange rate in the specified epoch // (and should be checked in transaction validation!), but including it allows // stateless verification that the transaction is internally consistent. - DelegationAmount *v1alpha1.Amount `protobuf:"bytes,4,opt,name=delegation_amount,json=delegationAmount,proto3" json:"delegation_amount,omitempty"` + DelegationAmount *v1alpha11.Amount `protobuf:"bytes,4,opt,name=delegation_amount,json=delegationAmount,proto3" json:"delegation_amount,omitempty"` } func (m *Delegate) Reset() { *m = Delegate{} } func (m *Delegate) String() string { return proto.CompactTextString(m) } func (*Delegate) ProtoMessage() {} func (*Delegate) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{10} + return fileDescriptor_b49c30b9d712baf6, []int{11} } func (m *Delegate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -953,14 +978,14 @@ func (m *Delegate) GetEpochIndex() uint64 { return 0 } -func (m *Delegate) GetUnbondedAmount() *v1alpha1.Amount { +func (m *Delegate) GetUnbondedAmount() *v1alpha11.Amount { if m != nil { return m.UnbondedAmount } return nil } -func (m *Delegate) GetDelegationAmount() *v1alpha1.Amount { +func (m *Delegate) GetDelegationAmount() *v1alpha11.Amount { if m != nil { return m.DelegationAmount } @@ -974,20 +999,20 @@ type Undelegate struct { // The index of the epoch in which this undelegation was performed. StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"` // The amount to undelegate, in units of unbonding tokens. - UnbondedAmount *v1alpha1.Amount `protobuf:"bytes,3,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"` + UnbondedAmount *v1alpha11.Amount `protobuf:"bytes,3,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"` // The amount of delegation tokens consumed by this action. // // This is implied by the validator's exchange rate in the specified epoch // (and should be checked in transaction validation!), but including it allows // stateless verification that the transaction is internally consistent. - DelegationAmount *v1alpha1.Amount `protobuf:"bytes,4,opt,name=delegation_amount,json=delegationAmount,proto3" json:"delegation_amount,omitempty"` + DelegationAmount *v1alpha11.Amount `protobuf:"bytes,4,opt,name=delegation_amount,json=delegationAmount,proto3" json:"delegation_amount,omitempty"` } func (m *Undelegate) Reset() { *m = Undelegate{} } func (m *Undelegate) String() string { return proto.CompactTextString(m) } func (*Undelegate) ProtoMessage() {} func (*Undelegate) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{11} + return fileDescriptor_b49c30b9d712baf6, []int{12} } func (m *Undelegate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1030,14 +1055,14 @@ func (m *Undelegate) GetStartEpochIndex() uint64 { return 0 } -func (m *Undelegate) GetUnbondedAmount() *v1alpha1.Amount { +func (m *Undelegate) GetUnbondedAmount() *v1alpha11.Amount { if m != nil { return m.UnbondedAmount } return nil } -func (m *Undelegate) GetDelegationAmount() *v1alpha1.Amount { +func (m *Undelegate) GetDelegationAmount() *v1alpha11.Amount { if m != nil { return m.DelegationAmount } @@ -1055,7 +1080,7 @@ func (m *UndelegateClaim) Reset() { *m = UndelegateClaim{} } func (m *UndelegateClaim) String() string { return proto.CompactTextString(m) } func (*UndelegateClaim) ProtoMessage() {} func (*UndelegateClaim) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{12} + return fileDescriptor_b49c30b9d712baf6, []int{13} } func (m *UndelegateClaim) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1107,14 +1132,14 @@ type UndelegateClaimBody struct { // In the happy path (no slashing), this is 0. Penalty *Penalty `protobuf:"bytes,3,opt,name=penalty,proto3" json:"penalty,omitempty"` // The action's contribution to the transaction's value balance. - BalanceCommitment *v1alpha1.BalanceCommitment `protobuf:"bytes,4,opt,name=balance_commitment,json=balanceCommitment,proto3" json:"balance_commitment,omitempty"` + BalanceCommitment *v1alpha12.BalanceCommitment `protobuf:"bytes,4,opt,name=balance_commitment,json=balanceCommitment,proto3" json:"balance_commitment,omitempty"` } func (m *UndelegateClaimBody) Reset() { *m = UndelegateClaimBody{} } func (m *UndelegateClaimBody) String() string { return proto.CompactTextString(m) } func (*UndelegateClaimBody) ProtoMessage() {} func (*UndelegateClaimBody) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{13} + return fileDescriptor_b49c30b9d712baf6, []int{14} } func (m *UndelegateClaimBody) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1164,7 +1189,7 @@ func (m *UndelegateClaimBody) GetPenalty() *Penalty { return nil } -func (m *UndelegateClaimBody) GetBalanceCommitment() *v1alpha1.BalanceCommitment { +func (m *UndelegateClaimBody) GetBalanceCommitment() *v1alpha12.BalanceCommitment { if m != nil { return m.BalanceCommitment } @@ -1181,7 +1206,7 @@ type UndelegateClaimPlan struct { Penalty *Penalty `protobuf:"bytes,4,opt,name=penalty,proto3" json:"penalty,omitempty"` // The amount of unbonding tokens to claim. // This is a bare number because its denom is determined by the preceding data. - UnbondingAmount *v1alpha1.Amount `protobuf:"bytes,5,opt,name=unbonding_amount,json=unbondingAmount,proto3" json:"unbonding_amount,omitempty"` + UnbondingAmount *v1alpha11.Amount `protobuf:"bytes,5,opt,name=unbonding_amount,json=unbondingAmount,proto3" json:"unbonding_amount,omitempty"` // The blinding factor to use for the balance commitment. BalanceBlinding []byte `protobuf:"bytes,6,opt,name=balance_blinding,json=balanceBlinding,proto3" json:"balance_blinding,omitempty"` // The first blinding factor to use for the ZK undelegate claim proof. @@ -1194,7 +1219,7 @@ func (m *UndelegateClaimPlan) Reset() { *m = UndelegateClaimPlan{} } func (m *UndelegateClaimPlan) String() string { return proto.CompactTextString(m) } func (*UndelegateClaimPlan) ProtoMessage() {} func (*UndelegateClaimPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{14} + return fileDescriptor_b49c30b9d712baf6, []int{15} } func (m *UndelegateClaimPlan) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1244,7 +1269,7 @@ func (m *UndelegateClaimPlan) GetPenalty() *Penalty { return nil } -func (m *UndelegateClaimPlan) GetUnbondingAmount() *v1alpha1.Amount { +func (m *UndelegateClaimPlan) GetUnbondingAmount() *v1alpha11.Amount { if m != nil { return m.UnbondingAmount } @@ -1282,7 +1307,7 @@ func (m *DelegationChanges) Reset() { *m = DelegationChanges{} } func (m *DelegationChanges) String() string { return proto.CompactTextString(m) } func (*DelegationChanges) ProtoMessage() {} func (*DelegationChanges) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{15} + return fileDescriptor_b49c30b9d712baf6, []int{16} } func (m *DelegationChanges) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1336,7 +1361,7 @@ func (m *Uptime) Reset() { *m = Uptime{} } func (m *Uptime) String() string { return proto.CompactTextString(m) } func (*Uptime) ProtoMessage() {} func (*Uptime) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{16} + return fileDescriptor_b49c30b9d712baf6, []int{17} } func (m *Uptime) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1396,7 +1421,7 @@ func (m *CurrentConsensusKeys) Reset() { *m = CurrentConsensusKeys{} } func (m *CurrentConsensusKeys) String() string { return proto.CompactTextString(m) } func (*CurrentConsensusKeys) ProtoMessage() {} func (*CurrentConsensusKeys) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{17} + return fileDescriptor_b49c30b9d712baf6, []int{18} } func (m *CurrentConsensusKeys) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1434,14 +1459,14 @@ func (m *CurrentConsensusKeys) GetConsensusKeys() []*v1alpha1.ConsensusKey { // Tracks slashing penalties applied to a validator in some epoch. type Penalty struct { - Inner uint64 `protobuf:"varint,1,opt,name=inner,proto3" json:"inner,omitempty"` + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` } func (m *Penalty) Reset() { *m = Penalty{} } func (m *Penalty) String() string { return proto.CompactTextString(m) } func (*Penalty) ProtoMessage() {} func (*Penalty) Descriptor() ([]byte, []int) { - return fileDescriptor_022d012c8e7b3ca5, []int{18} + return fileDescriptor_b49c30b9d712baf6, []int{19} } func (m *Penalty) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1470,626 +1495,973 @@ func (m *Penalty) XXX_DiscardUnknown() { var xxx_messageInfo_Penalty proto.InternalMessageInfo -func (m *Penalty) GetInner() uint64 { +func (m *Penalty) GetInner() []byte { if m != nil { return m.Inner } - return 0 + return nil } -func init() { - proto.RegisterEnum("penumbra.core.stake.v1alpha1.BondingState_BondingStateEnum", BondingState_BondingStateEnum_name, BondingState_BondingStateEnum_value) - proto.RegisterEnum("penumbra.core.stake.v1alpha1.ValidatorState_ValidatorStateEnum", ValidatorState_ValidatorStateEnum_name, ValidatorState_ValidatorStateEnum_value) - proto.RegisterType((*Validator)(nil), "penumbra.core.stake.v1alpha1.Validator") - proto.RegisterType((*ValidatorList)(nil), "penumbra.core.stake.v1alpha1.ValidatorList") - proto.RegisterType((*FundingStream)(nil), "penumbra.core.stake.v1alpha1.FundingStream") - proto.RegisterType((*FundingStream_ToAddress)(nil), "penumbra.core.stake.v1alpha1.FundingStream.ToAddress") - proto.RegisterType((*FundingStream_ToDao)(nil), "penumbra.core.stake.v1alpha1.FundingStream.ToDao") - proto.RegisterType((*RateData)(nil), "penumbra.core.stake.v1alpha1.RateData") - proto.RegisterType((*BaseRateData)(nil), "penumbra.core.stake.v1alpha1.BaseRateData") - proto.RegisterType((*ValidatorStatus)(nil), "penumbra.core.stake.v1alpha1.ValidatorStatus") - proto.RegisterType((*BondingState)(nil), "penumbra.core.stake.v1alpha1.BondingState") - proto.RegisterType((*ValidatorState)(nil), "penumbra.core.stake.v1alpha1.ValidatorState") - proto.RegisterType((*ValidatorInfo)(nil), "penumbra.core.stake.v1alpha1.ValidatorInfo") - proto.RegisterType((*ValidatorDefinition)(nil), "penumbra.core.stake.v1alpha1.ValidatorDefinition") - proto.RegisterType((*Delegate)(nil), "penumbra.core.stake.v1alpha1.Delegate") - proto.RegisterType((*Undelegate)(nil), "penumbra.core.stake.v1alpha1.Undelegate") - proto.RegisterType((*UndelegateClaim)(nil), "penumbra.core.stake.v1alpha1.UndelegateClaim") - proto.RegisterType((*UndelegateClaimBody)(nil), "penumbra.core.stake.v1alpha1.UndelegateClaimBody") - proto.RegisterType((*UndelegateClaimPlan)(nil), "penumbra.core.stake.v1alpha1.UndelegateClaimPlan") - proto.RegisterType((*DelegationChanges)(nil), "penumbra.core.stake.v1alpha1.DelegationChanges") - proto.RegisterType((*Uptime)(nil), "penumbra.core.stake.v1alpha1.Uptime") - proto.RegisterType((*CurrentConsensusKeys)(nil), "penumbra.core.stake.v1alpha1.CurrentConsensusKeys") - proto.RegisterType((*Penalty)(nil), "penumbra.core.stake.v1alpha1.Penalty") +// Requests information on the chain's validators. +type ValidatorInfoRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // Whether or not to return inactive validators + ShowInactive bool `protobuf:"varint,2,opt,name=show_inactive,json=showInactive,proto3" json:"show_inactive,omitempty"` } -func init() { - proto.RegisterFile("penumbra/core/stake/v1alpha1/stake.proto", fileDescriptor_022d012c8e7b3ca5) -} - -var fileDescriptor_022d012c8e7b3ca5 = []byte{ - // 1578 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0xcd, 0x6f, 0x23, 0x49, - 0x15, 0x4f, 0x3b, 0x76, 0x12, 0x3f, 0x7f, 0xa6, 0x66, 0x01, 0xcf, 0x30, 0x93, 0x78, 0x7b, 0x81, - 0x35, 0x33, 0x83, 0xc3, 0x04, 0xc1, 0x21, 0x7b, 0x58, 0xdc, 0xb6, 0x77, 0xe2, 0xdd, 0xc4, 0xf1, - 0xb6, 0x9d, 0x48, 0xa0, 0x48, 0xad, 0xb2, 0xbb, 0x62, 0x37, 0x63, 0x57, 0x99, 0xae, 0x72, 0xb2, - 0xfe, 0x0b, 0xe0, 0xc8, 0x71, 0xcf, 0x1c, 0x38, 0xac, 0x04, 0x12, 0x27, 0x4e, 0x70, 0x46, 0x9c, - 0x96, 0x1b, 0x47, 0x94, 0x91, 0x40, 0xe2, 0xaf, 0x40, 0x55, 0xdd, 0xd5, 0xfe, 0xc8, 0xd7, 0x64, - 0x35, 0x42, 0xcb, 0xad, 0xdf, 0x7b, 0xbf, 0xf7, 0xea, 0xbd, 0x5f, 0xd5, 0xab, 0x8f, 0x86, 0xd2, - 0x98, 0xd0, 0xc9, 0xa8, 0xeb, 0xe3, 0x9d, 0x1e, 0xf3, 0xc9, 0x0e, 0x17, 0xf8, 0x15, 0xd9, 0x39, - 0x7f, 0x81, 0x87, 0xe3, 0x01, 0x7e, 0x11, 0x88, 0xe5, 0xb1, 0xcf, 0x04, 0x43, 0x8f, 0x35, 0xb2, - 0x2c, 0x91, 0xe5, 0xc0, 0xa4, 0x91, 0x8f, 0x9e, 0x2e, 0xc6, 0xe9, 0xf9, 0xd3, 0xb1, 0x60, 0xb3, - 0x40, 0x81, 0x1c, 0x44, 0x32, 0xff, 0xbc, 0x0a, 0xc9, 0x13, 0x3c, 0xf4, 0x5c, 0x2c, 0x98, 0x8f, - 0x0e, 0x21, 0xed, 0xb9, 0x84, 0x0a, 0x4f, 0x4c, 0x9d, 0x57, 0x64, 0x5a, 0x30, 0x8a, 0x46, 0x29, - 0xb5, 0xfb, 0xb4, 0xbc, 0x38, 0x5c, 0x18, 0x40, 0x07, 0x2c, 0x37, 0x42, 0x97, 0x4f, 0xc8, 0xd4, - 0x4e, 0x79, 0x33, 0x01, 0xbd, 0x07, 0x99, 0x1e, 0xa3, 0x9c, 0x50, 0x3e, 0xe1, 0x2a, 0x5e, 0xac, - 0x68, 0x94, 0xd2, 0x76, 0x3a, 0x52, 0x4a, 0x10, 0x82, 0x38, 0xc5, 0x23, 0x52, 0x58, 0x2d, 0x1a, - 0xa5, 0xa4, 0xad, 0xbe, 0x51, 0x01, 0xd6, 0x2f, 0x48, 0x97, 0x7b, 0x82, 0x14, 0xe2, 0x4a, 0xad, - 0x45, 0x54, 0x84, 0x94, 0x4b, 0x78, 0xcf, 0xf7, 0xc6, 0xc2, 0x63, 0xb4, 0x90, 0x50, 0xd6, 0x79, - 0x95, 0xf4, 0x25, 0x14, 0x77, 0x87, 0xc4, 0x2d, 0x6c, 0x14, 0x8d, 0xd2, 0x86, 0xad, 0x45, 0xd4, - 0x81, 0xdc, 0xd9, 0x84, 0xba, 0x1e, 0xed, 0x3b, 0x5c, 0xf8, 0x04, 0x8f, 0x78, 0x61, 0xad, 0xb8, - 0x5a, 0x4a, 0xed, 0x3e, 0x2b, 0xdf, 0xc6, 0x67, 0xf9, 0xa3, 0xc0, 0xa9, 0xad, 0x7c, 0xec, 0xec, - 0xd9, 0xbc, 0xc8, 0xd1, 0xfb, 0x90, 0xe3, 0xe4, 0x97, 0x13, 0x42, 0x7b, 0xc4, 0x91, 0x41, 0x88, - 0x5f, 0x58, 0x2f, 0x1a, 0xa5, 0x8c, 0x9d, 0xd5, 0xea, 0xa6, 0xd2, 0xa2, 0x36, 0x64, 0xfb, 0xec, - 0x9c, 0xf8, 0x14, 0x4b, 0xa8, 0xa4, 0x23, 0xa9, 0xe8, 0x7d, 0x7e, 0x07, 0xbd, 0x2f, 0x23, 0x27, - 0x49, 0x70, 0xa6, 0x3f, 0x2f, 0x9a, 0x5d, 0xc8, 0x44, 0xd3, 0x77, 0xe0, 0x71, 0x81, 0x3e, 0x85, - 0xec, 0xb9, 0x56, 0xc8, 0x41, 0x78, 0xc1, 0x50, 0x35, 0xde, 0x67, 0x12, 0x33, 0x51, 0x84, 0x4f, - 0xc8, 0x94, 0x9b, 0xbf, 0x8b, 0x41, 0x66, 0x81, 0x03, 0x74, 0x02, 0x20, 0x98, 0x83, 0x5d, 0xd7, - 0x27, 0x9c, 0x87, 0xab, 0xe4, 0xc7, 0xf7, 0x20, 0xb1, 0xdc, 0x61, 0x95, 0xc0, 0x79, 0x7f, 0xc5, - 0x4e, 0x0a, 0x2d, 0xa0, 0x8f, 0x61, 0x4d, 0x30, 0xc7, 0xc5, 0x4c, 0xad, 0x94, 0xd4, 0xee, 0x8b, - 0xfb, 0xc5, 0xac, 0x61, 0xb6, 0xbf, 0x62, 0x27, 0x84, 0xfc, 0x78, 0xf4, 0x53, 0x48, 0x46, 0xa3, - 0xc8, 0x45, 0x31, 0x9f, 0x6d, 0xd2, 0xd6, 0x22, 0x7a, 0x08, 0x1b, 0x3e, 0x16, 0xc4, 0xe9, 0x8e, - 0xb9, 0x1a, 0x34, 0x63, 0xaf, 0x4b, 0xd9, 0x1a, 0xf3, 0x47, 0x26, 0x24, 0x54, 0xcc, 0x5b, 0x30, - 0x56, 0x0a, 0x92, 0x3e, 0xe9, 0x79, 0x63, 0x8f, 0x50, 0x61, 0xfe, 0xcb, 0x80, 0x0d, 0x1b, 0x0b, - 0x52, 0xc3, 0x02, 0xbf, 0xed, 0x5e, 0xda, 0x86, 0x14, 0x19, 0xb3, 0xde, 0xc0, 0xf1, 0xa8, 0x4b, - 0x3e, 0x53, 0x69, 0xc4, 0x6d, 0x50, 0xaa, 0x86, 0xd4, 0xa0, 0x5d, 0xf8, 0xc6, 0x6c, 0xe2, 0x7d, - 0x72, 0x81, 0x7d, 0xd7, 0x91, 0x59, 0xaa, 0x0e, 0x8a, 0xdb, 0x0f, 0x22, 0xa3, 0xad, 0x6c, 0x32, - 0x4f, 0xf4, 0x13, 0xf8, 0xd6, 0xcc, 0x87, 0x7c, 0xd6, 0x1b, 0x60, 0xda, 0x27, 0x81, 0x57, 0x42, - 0x79, 0xcd, 0x42, 0xd6, 0x43, 0xab, 0xf4, 0x33, 0x7f, 0x65, 0x40, 0xda, 0xc2, 0x9c, 0x44, 0xc5, - 0x2e, 0x65, 0x67, 0x5c, 0xc9, 0xae, 0x04, 0xf9, 0x2e, 0xe6, 0x64, 0x21, 0xb1, 0xa0, 0x86, 0xac, - 0xd4, 0xcf, 0xe5, 0xf4, 0x1c, 0x90, 0x42, 0x2e, 0xa6, 0xb3, 0xaa, 0xb0, 0x2a, 0xc6, 0x42, 0x26, - 0x9f, 0xc7, 0x20, 0x17, 0x35, 0x40, 0x5b, 0x60, 0x31, 0xe1, 0x6f, 0x9b, 0x79, 0x0b, 0x12, 0x5c, - 0xe8, 0x7c, 0xaf, 0xb6, 0xeb, 0xd2, 0x9a, 0x5c, 0x48, 0x86, 0xd8, 0x81, 0x2b, 0x7a, 0x17, 0xd2, - 0xe7, 0x4c, 0xc8, 0x9d, 0x67, 0xcc, 0x2e, 0x88, 0x1f, 0x96, 0x93, 0x0a, 0x74, 0x2d, 0xa9, 0x42, - 0x47, 0x90, 0xe9, 0x32, 0xbd, 0x3b, 0xe9, 0x79, 0xbb, 0x9a, 0xf6, 0xd2, 0x70, 0x16, 0x0b, 0x5b, - 0x40, 0x0e, 0x96, 0xee, 0xce, 0x49, 0xe6, 0x5f, 0x62, 0x90, 0x9e, 0x37, 0xa3, 0x4f, 0x75, 0x21, - 0x92, 0x90, 0xec, 0xee, 0x07, 0x6f, 0x1e, 0x79, 0x41, 0xa8, 0xd3, 0xc9, 0x48, 0xd7, 0xf5, 0x1c, - 0x72, 0x13, 0xaa, 0xd3, 0x56, 0xd3, 0x1d, 0xcc, 0xea, 0xfe, 0x8a, 0x9d, 0x8d, 0x0c, 0x75, 0xa9, - 0xff, 0xb5, 0x61, 0x98, 0x9f, 0x1b, 0x90, 0x5f, 0x8e, 0x84, 0x4c, 0xd8, 0xb2, 0x8e, 0x9a, 0xb5, - 0x46, 0xf3, 0xa5, 0xd3, 0xee, 0x54, 0x3a, 0x75, 0xa7, 0xde, 0x3c, 0x3e, 0x74, 0x8e, 0x9b, 0xed, - 0x56, 0xbd, 0xda, 0xf8, 0xa8, 0x51, 0xaf, 0xe5, 0x57, 0xd0, 0x13, 0x78, 0x78, 0x0d, 0x46, 0xaa, - 0xea, 0xb5, 0xbc, 0x81, 0x8a, 0xf0, 0xf8, 0xda, 0x10, 0xa1, 0x32, 0x1f, 0x43, 0xdb, 0xf0, 0xed, - 0x1b, 0x11, 0xf5, 0x5a, 0x7e, 0xd5, 0x42, 0x90, 0x77, 0x96, 0x2a, 0x31, 0xff, 0x1e, 0x83, 0xec, - 0xe2, 0x74, 0xa2, 0xe3, 0x45, 0x0a, 0x3f, 0xbc, 0xcf, 0x5a, 0x58, 0x12, 0xe7, 0x68, 0x34, 0xff, - 0x6d, 0x00, 0xba, 0x6a, 0x45, 0xdf, 0x81, 0xe2, 0x49, 0xe5, 0xa0, 0x51, 0xab, 0x74, 0x8e, 0xec, - 0x9b, 0xc9, 0x79, 0x17, 0x9e, 0x5c, 0x8b, 0x6a, 0x34, 0x2b, 0xd5, 0x4e, 0xe3, 0xa4, 0x9e, 0x37, - 0x64, 0xf9, 0xd7, 0x42, 0x42, 0x40, 0xec, 0x46, 0xc0, 0xc7, 0x95, 0xc6, 0x81, 0xe4, 0x07, 0xbd, - 0x07, 0xdb, 0xd7, 0x02, 0x3a, 0x47, 0x87, 0x56, 0xbb, 0x73, 0xd4, 0xac, 0xd7, 0xf2, 0xf1, 0x1b, - 0x33, 0xa9, 0x35, 0xda, 0x15, 0x4b, 0xc6, 0x49, 0x98, 0x97, 0xc6, 0xdc, 0x81, 0xd5, 0xa0, 0x67, - 0x0c, 0xd5, 0x21, 0x19, 0x6d, 0x32, 0x61, 0xab, 0xbe, 0xff, 0x86, 0xb4, 0xda, 0x33, 0x4f, 0x54, - 0x87, 0x35, 0xae, 0xda, 0x3f, 0x6c, 0xd3, 0x1f, 0xdc, 0x63, 0x6a, 0x26, 0xdc, 0x0e, 0x9d, 0x51, - 0x15, 0x92, 0x6a, 0xab, 0x77, 0xb1, 0xc0, 0xaa, 0x4b, 0x53, 0xbb, 0xdf, 0xbb, 0x3d, 0x92, 0xde, - 0x03, 0x6d, 0x75, 0x46, 0xc8, 0x2f, 0xf3, 0x02, 0x1e, 0x44, 0xf1, 0x6b, 0xe4, 0xcc, 0xa3, 0x9e, - 0xba, 0x99, 0xbc, 0xa5, 0x4a, 0x1f, 0xc2, 0x06, 0x9e, 0x88, 0x81, 0xc3, 0xbd, 0x7e, 0x78, 0xa1, - 0x5a, 0x97, 0x72, 0xdb, 0xeb, 0x9b, 0x5f, 0xc4, 0x60, 0xa3, 0x46, 0x86, 0xa4, 0x2f, 0xd7, 0xea, - 0xcf, 0x00, 0xcd, 0x36, 0x77, 0xbd, 0xa1, 0x7d, 0x85, 0xcd, 0x70, 0x33, 0x8a, 0xa2, 0xb5, 0x77, - 0x1f, 0x46, 0x4d, 0xbd, 0x2f, 0x10, 0xd7, 0xc1, 0x23, 0x36, 0xa1, 0x22, 0x24, 0xf3, 0xbb, 0x77, - 0x0c, 0x5c, 0x51, 0x60, 0xbd, 0x79, 0x10, 0x37, 0x90, 0x91, 0x0d, 0x9b, 0x6e, 0x50, 0x97, 0xc7, - 0xa8, 0x8e, 0x18, 0xbf, 0x4f, 0xc4, 0xfc, 0xcc, 0x3f, 0xd0, 0x98, 0x7f, 0x8a, 0x01, 0x1c, 0x53, - 0xf7, 0x7f, 0x40, 0xd7, 0x53, 0xd8, 0xe4, 0x02, 0xfb, 0xc2, 0xb9, 0x4a, 0x5a, 0x4e, 0x19, 0xea, - 0xff, 0x5f, 0xcc, 0x51, 0xc8, 0xcd, 0x88, 0xab, 0x0e, 0xb1, 0x37, 0x42, 0x75, 0x88, 0x77, 0x99, - 0xab, 0xf9, 0xba, 0xe3, 0xde, 0xb6, 0xe4, 0x6c, 0x31, 0x77, 0x6a, 0x2b, 0x77, 0xf4, 0x0e, 0x24, - 0xc6, 0x3e, 0x63, 0x67, 0xe1, 0xc2, 0x0e, 0x04, 0x79, 0x92, 0x3d, 0xb8, 0xc6, 0xe7, 0xeb, 0x32, - 0x65, 0x1f, 0xc2, 0xfa, 0x98, 0x50, 0x3c, 0x14, 0xd3, 0x1b, 0xa6, 0x6a, 0xa9, 0xfc, 0x56, 0x00, - 0xb6, 0xb5, 0x17, 0x72, 0xe4, 0x95, 0x67, 0xa8, 0x9e, 0x05, 0x3d, 0x36, 0x1a, 0x79, 0x62, 0x44, - 0xa2, 0x49, 0xfa, 0xe1, 0x1d, 0x75, 0x58, 0x81, 0x63, 0x35, 0xf2, 0xb3, 0x37, 0xbb, 0xcb, 0x2a, - 0xf3, 0x0f, 0xab, 0x57, 0x08, 0x6c, 0x0d, 0x31, 0xfd, 0x1a, 0x12, 0x18, 0xff, 0x4a, 0x04, 0xb6, - 0x20, 0x3f, 0x3b, 0xbc, 0xc3, 0x35, 0x9e, 0xb8, 0xcf, 0x1a, 0x9f, 0xdd, 0x62, 0xc2, 0xb6, 0xf9, - 0xbe, 0xbc, 0xaf, 0x06, 0x53, 0xd2, 0x1d, 0x7a, 0xca, 0x52, 0x58, 0x53, 0x6b, 0x32, 0x17, 0xea, - 0xad, 0x50, 0x2d, 0xaf, 0xb6, 0x6a, 0x99, 0x46, 0x40, 0x27, 0x78, 0x01, 0xa6, 0xed, 0xac, 0xd2, - 0x6b, 0xa0, 0x7d, 0x0d, 0x92, 0xab, 0x37, 0xea, 0x32, 0xb2, 0x6d, 0xfe, 0xde, 0x80, 0xcd, 0x5a, - 0xd4, 0x76, 0x55, 0x75, 0xdf, 0xe5, 0x68, 0x5f, 0x3e, 0x7e, 0xb5, 0x52, 0x3f, 0xec, 0xee, 0x38, - 0x9e, 0xf4, 0x71, 0x60, 0xcf, 0xbb, 0xa2, 0x26, 0x64, 0x26, 0x74, 0x3e, 0x56, 0x4c, 0xc5, 0x2a, - 0xbd, 0x69, 0xdf, 0xda, 0x8b, 0xee, 0xe6, 0x10, 0xd6, 0x8e, 0xc7, 0xc2, 0x1b, 0x11, 0xf4, 0x0c, - 0x10, 0xe6, 0x8e, 0xaa, 0x91, 0xf5, 0x5e, 0x39, 0x03, 0xe2, 0xf5, 0x07, 0x22, 0x7c, 0x10, 0xe4, - 0x30, 0x3f, 0x3a, 0xb3, 0xa4, 0x7e, 0x5f, 0xa9, 0xd1, 0x13, 0x80, 0x0b, 0x8f, 0xba, 0xec, 0xc2, - 0x19, 0x12, 0x1a, 0x3e, 0xad, 0x92, 0x81, 0xe6, 0x80, 0x50, 0xf4, 0x4d, 0x58, 0xeb, 0x7a, 0xe2, - 0x9c, 0xf4, 0x54, 0x5f, 0xa5, 0xed, 0x50, 0x32, 0x7f, 0x01, 0xef, 0x54, 0x27, 0xbe, 0x4f, 0xa8, - 0xa8, 0xce, 0xfd, 0x49, 0xe0, 0xc8, 0x86, 0xec, 0xc2, 0xff, 0x06, 0x4d, 0xd1, 0xb3, 0x3b, 0x16, - 0xc1, 0x7c, 0x14, 0x3b, 0x33, 0xff, 0x77, 0x82, 0x9b, 0xdb, 0xb0, 0x1e, 0x2e, 0x37, 0xb9, 0x39, - 0x79, 0x94, 0x12, 0x3f, 0xac, 0x26, 0x10, 0xac, 0x3f, 0xc6, 0xfe, 0x7a, 0xb9, 0x65, 0x7c, 0x79, - 0xb9, 0x65, 0xfc, 0xf3, 0x72, 0xcb, 0xf8, 0xcd, 0xeb, 0xad, 0x95, 0x2f, 0x5f, 0x6f, 0xad, 0xfc, - 0xe3, 0xf5, 0xd6, 0x0a, 0x14, 0x7b, 0x6c, 0x74, 0x2b, 0xa3, 0x16, 0xb4, 0xa5, 0xdc, 0xf2, 0x99, - 0x60, 0x2d, 0xe3, 0xe7, 0x27, 0x7d, 0x4f, 0x0c, 0x26, 0xdd, 0x72, 0x8f, 0x8d, 0x76, 0x7a, 0x8c, - 0x8f, 0x18, 0xdf, 0xf1, 0xc9, 0x10, 0x4f, 0x89, 0xbf, 0x73, 0xbe, 0x1b, 0x7d, 0xf6, 0x06, 0xd8, - 0xa3, 0x7c, 0xe7, 0xb6, 0x9f, 0x45, 0x1f, 0x28, 0x51, 0x4b, 0xbf, 0x8d, 0xad, 0xb6, 0xaa, 0xed, - 0x2f, 0x62, 0x8f, 0x5b, 0x3a, 0x95, 0xaa, 0x4c, 0x45, 0x0d, 0x5d, 0x3e, 0x09, 0x41, 0x7f, 0x9b, - 0x99, 0x4f, 0xa5, 0xf9, 0x54, 0x99, 0x4f, 0xb5, 0xf9, 0x32, 0x56, 0xba, 0xcd, 0x7c, 0xfa, 0xb2, - 0x65, 0x1d, 0x12, 0x81, 0xe5, 0xb5, 0xe9, 0x3f, 0xb1, 0x6d, 0x0d, 0xdd, 0xdb, 0x93, 0xd8, 0xbd, - 0x3d, 0x05, 0xde, 0xdb, 0xd3, 0xe8, 0xee, 0x9a, 0xfa, 0xf9, 0xf4, 0xa3, 0xff, 0x06, 0x00, 0x00, - 0xff, 0xff, 0x34, 0xe3, 0xd1, 0x50, 0xf2, 0x12, 0x00, 0x00, +func (m *ValidatorInfoRequest) Reset() { *m = ValidatorInfoRequest{} } +func (m *ValidatorInfoRequest) String() string { return proto.CompactTextString(m) } +func (*ValidatorInfoRequest) ProtoMessage() {} +func (*ValidatorInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{20} } - -func (m *Validator) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *ValidatorInfoRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorInfoRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil } - -func (m *Validator) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *ValidatorInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorInfoRequest.Merge(m, src) +} +func (m *ValidatorInfoRequest) XXX_Size() int { + return m.Size() +} +func (m *ValidatorInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorInfoRequest.DiscardUnknown(m) } -func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.GovernanceKey != nil { - { - size, err := m.GovernanceKey.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x4a - } - if m.Enabled { - i-- - if m.Enabled { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x40 - } - if m.SequenceNumber != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.SequenceNumber)) - i-- - dAtA[i] = 0x38 - } - if len(m.FundingStreams) > 0 { - for iNdEx := len(m.FundingStreams) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.FundingStreams[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - } - if len(m.Description) > 0 { - i -= len(m.Description) - copy(dAtA[i:], m.Description) - i = encodeVarintStake(dAtA, i, uint64(len(m.Description))) - i-- - dAtA[i] = 0x2a - } - if len(m.Website) > 0 { - i -= len(m.Website) - copy(dAtA[i:], m.Website) - i = encodeVarintStake(dAtA, i, uint64(len(m.Website))) - i-- - dAtA[i] = 0x22 - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintStake(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0x1a - } - if len(m.ConsensusKey) > 0 { - i -= len(m.ConsensusKey) - copy(dAtA[i:], m.ConsensusKey) - i = encodeVarintStake(dAtA, i, uint64(len(m.ConsensusKey))) - i-- - dAtA[i] = 0x12 - } - if m.IdentityKey != nil { - { - size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa +var xxx_messageInfo_ValidatorInfoRequest proto.InternalMessageInfo + +func (m *ValidatorInfoRequest) GetChainId() string { + if m != nil { + return m.ChainId } - return len(dAtA) - i, nil + return "" } -func (m *ValidatorList) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *ValidatorInfoRequest) GetShowInactive() bool { + if m != nil { + return m.ShowInactive } - return dAtA[:n], nil + return false } -func (m *ValidatorList) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type ValidatorInfoResponse struct { + ValidatorInfo *ValidatorInfo `protobuf:"bytes,1,opt,name=validator_info,json=validatorInfo,proto3" json:"validator_info,omitempty"` } -func (m *ValidatorList) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ValidatorKeys) > 0 { - for iNdEx := len(m.ValidatorKeys) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.ValidatorKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa +func (m *ValidatorInfoResponse) Reset() { *m = ValidatorInfoResponse{} } +func (m *ValidatorInfoResponse) String() string { return proto.CompactTextString(m) } +func (*ValidatorInfoResponse) ProtoMessage() {} +func (*ValidatorInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{21} +} +func (m *ValidatorInfoResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorInfoResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *ValidatorInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorInfoResponse.Merge(m, src) +} +func (m *ValidatorInfoResponse) XXX_Size() int { + return m.Size() +} +func (m *ValidatorInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorInfoResponse.DiscardUnknown(m) } -func (m *FundingStream) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_ValidatorInfoResponse proto.InternalMessageInfo + +func (m *ValidatorInfoResponse) GetValidatorInfo() *ValidatorInfo { + if m != nil { + return m.ValidatorInfo } - return dAtA[:n], nil + return nil } -func (m *FundingStream) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type ValidatorStatusRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` } -func (m *FundingStream) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Recipient != nil { - { - size := m.Recipient.Size() - i -= size - if _, err := m.Recipient.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } +func (m *ValidatorStatusRequest) Reset() { *m = ValidatorStatusRequest{} } +func (m *ValidatorStatusRequest) String() string { return proto.CompactTextString(m) } +func (*ValidatorStatusRequest) ProtoMessage() {} +func (*ValidatorStatusRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{22} +} +func (m *ValidatorStatusRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorStatusRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *ValidatorStatusRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorStatusRequest.Merge(m, src) +} +func (m *ValidatorStatusRequest) XXX_Size() int { + return m.Size() +} +func (m *ValidatorStatusRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorStatusRequest.DiscardUnknown(m) } -func (m *FundingStream_ToAddress_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +var xxx_messageInfo_ValidatorStatusRequest proto.InternalMessageInfo + +func (m *ValidatorStatusRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" } -func (m *FundingStream_ToAddress_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.ToAddress != nil { - { - size, err := m.ToAddress.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa +func (m *ValidatorStatusRequest) GetIdentityKey() *v1alpha1.IdentityKey { + if m != nil { + return m.IdentityKey } - return len(dAtA) - i, nil + return nil } -func (m *FundingStream_ToDao_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + +type ValidatorStatusResponse struct { + Status *ValidatorStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` } -func (m *FundingStream_ToDao_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.ToDao != nil { - { - size, err := m.ToDao.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) +func (m *ValidatorStatusResponse) Reset() { *m = ValidatorStatusResponse{} } +func (m *ValidatorStatusResponse) String() string { return proto.CompactTextString(m) } +func (*ValidatorStatusResponse) ProtoMessage() {} +func (*ValidatorStatusResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{23} +} +func (m *ValidatorStatusResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorStatusResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0x12 + return b[:n], nil } - return len(dAtA) - i, nil } -func (m *FundingStream_ToAddress) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *ValidatorStatusResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorStatusResponse.Merge(m, src) +} +func (m *ValidatorStatusResponse) XXX_Size() int { + return m.Size() +} +func (m *ValidatorStatusResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorStatusResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorStatusResponse proto.InternalMessageInfo + +func (m *ValidatorStatusResponse) GetStatus() *ValidatorStatus { + if m != nil { + return m.Status } - return dAtA[:n], nil + return nil } -func (m *FundingStream_ToAddress) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// Requests the compounded penalty for a validator over a range of epochs. +type ValidatorPenaltyRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` + StartEpochIndex uint64 `protobuf:"varint,3,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"` + EndEpochIndex uint64 `protobuf:"varint,4,opt,name=end_epoch_index,json=endEpochIndex,proto3" json:"end_epoch_index,omitempty"` } -func (m *FundingStream_ToAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.RateBps != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.RateBps)) - i-- - dAtA[i] = 0x10 - } - if len(m.Address) > 0 { - i -= len(m.Address) - copy(dAtA[i:], m.Address) - i = encodeVarintStake(dAtA, i, uint64(len(m.Address))) - i-- - dAtA[i] = 0xa +func (m *ValidatorPenaltyRequest) Reset() { *m = ValidatorPenaltyRequest{} } +func (m *ValidatorPenaltyRequest) String() string { return proto.CompactTextString(m) } +func (*ValidatorPenaltyRequest) ProtoMessage() {} +func (*ValidatorPenaltyRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{24} +} +func (m *ValidatorPenaltyRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorPenaltyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorPenaltyRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *ValidatorPenaltyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorPenaltyRequest.Merge(m, src) +} +func (m *ValidatorPenaltyRequest) XXX_Size() int { + return m.Size() +} +func (m *ValidatorPenaltyRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorPenaltyRequest.DiscardUnknown(m) } -func (m *FundingStream_ToDao) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_ValidatorPenaltyRequest proto.InternalMessageInfo + +func (m *ValidatorPenaltyRequest) GetChainId() string { + if m != nil { + return m.ChainId } - return dAtA[:n], nil + return "" } -func (m *FundingStream_ToDao) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *ValidatorPenaltyRequest) GetIdentityKey() *v1alpha1.IdentityKey { + if m != nil { + return m.IdentityKey + } + return nil } -func (m *FundingStream_ToDao) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.RateBps != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.RateBps)) - i-- - dAtA[i] = 0x10 +func (m *ValidatorPenaltyRequest) GetStartEpochIndex() uint64 { + if m != nil { + return m.StartEpochIndex } - return len(dAtA) - i, nil + return 0 } -func (m *RateData) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *ValidatorPenaltyRequest) GetEndEpochIndex() uint64 { + if m != nil { + return m.EndEpochIndex } - return dAtA[:n], nil + return 0 } -func (m *RateData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type ValidatorPenaltyResponse struct { + Penalty *Penalty `protobuf:"bytes,1,opt,name=penalty,proto3" json:"penalty,omitempty"` } -func (m *RateData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.ValidatorExchangeRate != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.ValidatorExchangeRate)) - i-- - dAtA[i] = 0x28 - } - if m.ValidatorRewardRate != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.ValidatorRewardRate)) - i-- - dAtA[i] = 0x20 - } - if m.EpochIndex != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex)) - i-- - dAtA[i] = 0x10 - } - if m.IdentityKey != nil { - { - size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) +func (m *ValidatorPenaltyResponse) Reset() { *m = ValidatorPenaltyResponse{} } +func (m *ValidatorPenaltyResponse) String() string { return proto.CompactTextString(m) } +func (*ValidatorPenaltyResponse) ProtoMessage() {} +func (*ValidatorPenaltyResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{25} +} +func (m *ValidatorPenaltyResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorPenaltyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorPenaltyResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0xa + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *ValidatorPenaltyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorPenaltyResponse.Merge(m, src) +} +func (m *ValidatorPenaltyResponse) XXX_Size() int { + return m.Size() +} +func (m *ValidatorPenaltyResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorPenaltyResponse.DiscardUnknown(m) } -func (m *BaseRateData) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_ValidatorPenaltyResponse proto.InternalMessageInfo + +func (m *ValidatorPenaltyResponse) GetPenalty() *Penalty { + if m != nil { + return m.Penalty } - return dAtA[:n], nil + return nil } -func (m *BaseRateData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type CurrentValidatorRateRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` } -func (m *BaseRateData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.BaseExchangeRate != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.BaseExchangeRate)) - i-- - dAtA[i] = 0x18 - } - if m.BaseRewardRate != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.BaseRewardRate)) - i-- - dAtA[i] = 0x10 +func (m *CurrentValidatorRateRequest) Reset() { *m = CurrentValidatorRateRequest{} } +func (m *CurrentValidatorRateRequest) String() string { return proto.CompactTextString(m) } +func (*CurrentValidatorRateRequest) ProtoMessage() {} +func (*CurrentValidatorRateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{26} +} +func (m *CurrentValidatorRateRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CurrentValidatorRateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CurrentValidatorRateRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - if m.EpochIndex != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex)) - i-- - dAtA[i] = 0x8 +} +func (m *CurrentValidatorRateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CurrentValidatorRateRequest.Merge(m, src) +} +func (m *CurrentValidatorRateRequest) XXX_Size() int { + return m.Size() +} +func (m *CurrentValidatorRateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CurrentValidatorRateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_CurrentValidatorRateRequest proto.InternalMessageInfo + +func (m *CurrentValidatorRateRequest) GetChainId() string { + if m != nil { + return m.ChainId } - return len(dAtA) - i, nil + return "" } -func (m *ValidatorStatus) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *CurrentValidatorRateRequest) GetIdentityKey() *v1alpha1.IdentityKey { + if m != nil { + return m.IdentityKey } - return dAtA[:n], nil + return nil } -func (m *ValidatorStatus) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type CurrentValidatorRateResponse struct { + Data *RateData `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` } -func (m *ValidatorStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.BondingState != nil { - { - size, err := m.BondingState.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 +func (m *CurrentValidatorRateResponse) Reset() { *m = CurrentValidatorRateResponse{} } +func (m *CurrentValidatorRateResponse) String() string { return proto.CompactTextString(m) } +func (*CurrentValidatorRateResponse) ProtoMessage() {} +func (*CurrentValidatorRateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{27} +} +func (m *CurrentValidatorRateResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CurrentValidatorRateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CurrentValidatorRateResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - if m.VotingPower != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.VotingPower)) - i-- - dAtA[i] = 0x18 +} +func (m *CurrentValidatorRateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CurrentValidatorRateResponse.Merge(m, src) +} +func (m *CurrentValidatorRateResponse) XXX_Size() int { + return m.Size() +} +func (m *CurrentValidatorRateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CurrentValidatorRateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CurrentValidatorRateResponse proto.InternalMessageInfo + +func (m *CurrentValidatorRateResponse) GetData() *RateData { + if m != nil { + return m.Data } - if m.State != nil { - { - size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) + return nil +} + +// Staking configuration data. +type StakeParameters struct { + // The number of epochs an unbonding note for before being released. + UnbondingEpochs uint64 `protobuf:"varint,1,opt,name=unbonding_epochs,json=unbondingEpochs,proto3" json:"unbonding_epochs,omitempty"` + // The maximum number of validators in the consensus set. + ActiveValidatorLimit uint64 `protobuf:"varint,2,opt,name=active_validator_limit,json=activeValidatorLimit,proto3" json:"active_validator_limit,omitempty"` + // The base reward rate, expressed in basis points of basis points + BaseRewardRate uint64 `protobuf:"varint,3,opt,name=base_reward_rate,json=baseRewardRate,proto3" json:"base_reward_rate,omitempty"` + // The penalty for slashing due to misbehavior. + SlashingPenaltyMisbehavior uint64 `protobuf:"varint,4,opt,name=slashing_penalty_misbehavior,json=slashingPenaltyMisbehavior,proto3" json:"slashing_penalty_misbehavior,omitempty"` + // The penalty for slashing due to downtime. + SlashingPenaltyDowntime uint64 `protobuf:"varint,5,opt,name=slashing_penalty_downtime,json=slashingPenaltyDowntime,proto3" json:"slashing_penalty_downtime,omitempty"` + // The number of blocks in the window to check for downtime. + SignedBlocksWindowLen uint64 `protobuf:"varint,6,opt,name=signed_blocks_window_len,json=signedBlocksWindowLen,proto3" json:"signed_blocks_window_len,omitempty"` + // The maximum number of blocks in the window each validator can miss signing without slashing. + MissedBlocksMaximum uint64 `protobuf:"varint,7,opt,name=missed_blocks_maximum,json=missedBlocksMaximum,proto3" json:"missed_blocks_maximum,omitempty"` +} + +func (m *StakeParameters) Reset() { *m = StakeParameters{} } +func (m *StakeParameters) String() string { return proto.CompactTextString(m) } +func (*StakeParameters) ProtoMessage() {} +func (*StakeParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{28} +} +func (m *StakeParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StakeParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StakeParameters.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0x12 + return b[:n], nil } - if m.IdentityKey != nil { - { - size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) +} +func (m *StakeParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_StakeParameters.Merge(m, src) +} +func (m *StakeParameters) XXX_Size() int { + return m.Size() +} +func (m *StakeParameters) XXX_DiscardUnknown() { + xxx_messageInfo_StakeParameters.DiscardUnknown(m) +} + +var xxx_messageInfo_StakeParameters proto.InternalMessageInfo + +func (m *StakeParameters) GetUnbondingEpochs() uint64 { + if m != nil { + return m.UnbondingEpochs + } + return 0 +} + +func (m *StakeParameters) GetActiveValidatorLimit() uint64 { + if m != nil { + return m.ActiveValidatorLimit + } + return 0 +} + +func (m *StakeParameters) GetBaseRewardRate() uint64 { + if m != nil { + return m.BaseRewardRate + } + return 0 +} + +func (m *StakeParameters) GetSlashingPenaltyMisbehavior() uint64 { + if m != nil { + return m.SlashingPenaltyMisbehavior + } + return 0 +} + +func (m *StakeParameters) GetSlashingPenaltyDowntime() uint64 { + if m != nil { + return m.SlashingPenaltyDowntime + } + return 0 +} + +func (m *StakeParameters) GetSignedBlocksWindowLen() uint64 { + if m != nil { + return m.SignedBlocksWindowLen + } + return 0 +} + +func (m *StakeParameters) GetMissedBlocksMaximum() uint64 { + if m != nil { + return m.MissedBlocksMaximum + } + return 0 +} + +// Genesis data for the staking component. +type GenesisContent struct { + // The configuration parameters for the staking component present at genesis + StakeParams *StakeParameters `protobuf:"bytes,1,opt,name=stake_params,json=stakeParams,proto3" json:"stake_params,omitempty"` + // The list of validators present at genesis. + Validators []*Validator `protobuf:"bytes,2,rep,name=validators,proto3" json:"validators,omitempty"` +} + +func (m *GenesisContent) Reset() { *m = GenesisContent{} } +func (m *GenesisContent) String() string { return proto.CompactTextString(m) } +func (*GenesisContent) ProtoMessage() {} +func (*GenesisContent) Descriptor() ([]byte, []int) { + return fileDescriptor_b49c30b9d712baf6, []int{29} +} +func (m *GenesisContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisContent.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0xa + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *GenesisContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisContent.Merge(m, src) +} +func (m *GenesisContent) XXX_Size() int { + return m.Size() +} +func (m *GenesisContent) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisContent.DiscardUnknown(m) } -func (m *BondingState) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +var xxx_messageInfo_GenesisContent proto.InternalMessageInfo + +func (m *GenesisContent) GetStakeParams() *StakeParameters { + if m != nil { + return m.StakeParams + } + return nil +} + +func (m *GenesisContent) GetValidators() []*Validator { + if m != nil { + return m.Validators + } + return nil +} + +func init() { + proto.RegisterEnum("penumbra.core.component.stake.v1alpha1.BondingState_BondingStateEnum", BondingState_BondingStateEnum_name, BondingState_BondingStateEnum_value) + proto.RegisterEnum("penumbra.core.component.stake.v1alpha1.ValidatorState_ValidatorStateEnum", ValidatorState_ValidatorStateEnum_name, ValidatorState_ValidatorStateEnum_value) + proto.RegisterType((*ZKUndelegateClaimProof)(nil), "penumbra.core.component.stake.v1alpha1.ZKUndelegateClaimProof") + proto.RegisterType((*Validator)(nil), "penumbra.core.component.stake.v1alpha1.Validator") + proto.RegisterType((*ValidatorList)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorList") + proto.RegisterType((*FundingStream)(nil), "penumbra.core.component.stake.v1alpha1.FundingStream") + proto.RegisterType((*FundingStream_ToAddress)(nil), "penumbra.core.component.stake.v1alpha1.FundingStream.ToAddress") + proto.RegisterType((*FundingStream_ToCommunityPool)(nil), "penumbra.core.component.stake.v1alpha1.FundingStream.ToCommunityPool") + proto.RegisterType((*RateData)(nil), "penumbra.core.component.stake.v1alpha1.RateData") + proto.RegisterType((*BaseRateData)(nil), "penumbra.core.component.stake.v1alpha1.BaseRateData") + proto.RegisterType((*ValidatorStatus)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorStatus") + proto.RegisterType((*BondingState)(nil), "penumbra.core.component.stake.v1alpha1.BondingState") + proto.RegisterType((*ValidatorState)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorState") + proto.RegisterType((*ValidatorInfo)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorInfo") + proto.RegisterType((*ValidatorDefinition)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorDefinition") + proto.RegisterType((*Delegate)(nil), "penumbra.core.component.stake.v1alpha1.Delegate") + proto.RegisterType((*Undelegate)(nil), "penumbra.core.component.stake.v1alpha1.Undelegate") + proto.RegisterType((*UndelegateClaim)(nil), "penumbra.core.component.stake.v1alpha1.UndelegateClaim") + proto.RegisterType((*UndelegateClaimBody)(nil), "penumbra.core.component.stake.v1alpha1.UndelegateClaimBody") + proto.RegisterType((*UndelegateClaimPlan)(nil), "penumbra.core.component.stake.v1alpha1.UndelegateClaimPlan") + proto.RegisterType((*DelegationChanges)(nil), "penumbra.core.component.stake.v1alpha1.DelegationChanges") + proto.RegisterType((*Uptime)(nil), "penumbra.core.component.stake.v1alpha1.Uptime") + proto.RegisterType((*CurrentConsensusKeys)(nil), "penumbra.core.component.stake.v1alpha1.CurrentConsensusKeys") + proto.RegisterType((*Penalty)(nil), "penumbra.core.component.stake.v1alpha1.Penalty") + proto.RegisterType((*ValidatorInfoRequest)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorInfoRequest") + proto.RegisterType((*ValidatorInfoResponse)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorInfoResponse") + proto.RegisterType((*ValidatorStatusRequest)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorStatusRequest") + proto.RegisterType((*ValidatorStatusResponse)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorStatusResponse") + proto.RegisterType((*ValidatorPenaltyRequest)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorPenaltyRequest") + proto.RegisterType((*ValidatorPenaltyResponse)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorPenaltyResponse") + proto.RegisterType((*CurrentValidatorRateRequest)(nil), "penumbra.core.component.stake.v1alpha1.CurrentValidatorRateRequest") + proto.RegisterType((*CurrentValidatorRateResponse)(nil), "penumbra.core.component.stake.v1alpha1.CurrentValidatorRateResponse") + proto.RegisterType((*StakeParameters)(nil), "penumbra.core.component.stake.v1alpha1.StakeParameters") + proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.stake.v1alpha1.GenesisContent") +} + +func init() { + proto.RegisterFile("penumbra/core/component/stake/v1alpha1/stake.proto", fileDescriptor_b49c30b9d712baf6) +} + +var fileDescriptor_b49c30b9d712baf6 = []byte{ + // 2141 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x6f, 0x1b, 0xc7, + 0x15, 0xd7, 0x52, 0xd4, 0xd7, 0x23, 0x29, 0x52, 0xe3, 0x2f, 0x5a, 0xb1, 0x65, 0x65, 0x1d, 0x38, + 0x8a, 0x1b, 0x50, 0x31, 0x9b, 0x0f, 0x40, 0x69, 0x1b, 0x8b, 0x1f, 0xb1, 0x59, 0x5b, 0x12, 0xbd, + 0x94, 0x9d, 0xd6, 0x15, 0xb2, 0x5e, 0x72, 0x47, 0xe4, 0xd6, 0xdc, 0x19, 0x66, 0x67, 0x28, 0x59, + 0xb7, 0xf4, 0x50, 0xe4, 0x56, 0x14, 0x05, 0x0a, 0xf4, 0xda, 0x1c, 0x73, 0xe9, 0xa1, 0x7f, 0x40, + 0x51, 0x14, 0x05, 0x8a, 0x9e, 0x72, 0x29, 0x50, 0xa0, 0x97, 0xc2, 0x2e, 0x50, 0xa0, 0x97, 0xf6, + 0x4f, 0x28, 0x66, 0x76, 0xf6, 0x83, 0x14, 0xe5, 0x50, 0xb4, 0x1b, 0xa4, 0x17, 0x81, 0xef, 0xcd, + 0xef, 0xbd, 0x7d, 0xf3, 0xe6, 0xbd, 0x37, 0xef, 0x8d, 0xa0, 0xd8, 0xc3, 0xa4, 0xef, 0x36, 0x3d, + 0x6b, 0xbd, 0x45, 0x3d, 0xbc, 0xde, 0xa2, 0x6e, 0x8f, 0x12, 0x4c, 0xf8, 0x3a, 0xe3, 0xd6, 0x63, + 0xbc, 0x7e, 0x70, 0xc3, 0xea, 0xf6, 0x3a, 0xd6, 0x0d, 0x9f, 0x2c, 0xf4, 0x3c, 0xca, 0x29, 0xba, + 0x16, 0xc8, 0x14, 0x84, 0x4c, 0x21, 0x94, 0x29, 0xf8, 0xa0, 0x40, 0x66, 0x79, 0x6d, 0x50, 0xb7, + 0xc5, 0x18, 0xe6, 0x91, 0x46, 0x49, 0xfa, 0x1a, 0x97, 0xaf, 0x0d, 0x22, 0x1f, 0xe3, 0x23, 0x16, + 0x01, 0x05, 0xa5, 0x70, 0xaf, 0x0d, 0xe2, 0x48, 0xdf, 0x8d, 0x60, 0xa4, 0xef, 0xfa, 0x28, 0xbd, + 0x00, 0xe7, 0x1f, 0xde, 0xb9, 0x4f, 0x6c, 0xdc, 0xc5, 0x6d, 0x8b, 0xe3, 0x72, 0xd7, 0x72, 0xdc, + 0xba, 0x47, 0xe9, 0x3e, 0x3a, 0x0b, 0x33, 0x0e, 0x21, 0xd8, 0xcb, 0x6b, 0xab, 0xda, 0x5a, 0xda, + 0xf0, 0x09, 0xfd, 0x0f, 0xd3, 0xb0, 0xf0, 0xc0, 0xea, 0x3a, 0xb6, 0xc5, 0xa9, 0x87, 0xee, 0x40, + 0xda, 0xb1, 0x31, 0xe1, 0x0e, 0x3f, 0x32, 0x1f, 0xe3, 0x23, 0x09, 0x4d, 0x15, 0xd7, 0x0a, 0x83, + 0x9b, 0x96, 0x46, 0x05, 0xdf, 0x2e, 0xd4, 0x94, 0xc0, 0x1d, 0x7c, 0x64, 0xa4, 0x9c, 0x88, 0x40, + 0x57, 0x21, 0xd3, 0xa2, 0x84, 0x61, 0xc2, 0xfa, 0x4c, 0x6a, 0x4b, 0xc8, 0x0f, 0xa7, 0x43, 0xa6, + 0x00, 0x21, 0x48, 0x12, 0xcb, 0xc5, 0xf9, 0xe9, 0x55, 0x6d, 0x6d, 0xc1, 0x90, 0xbf, 0x51, 0x1e, + 0xe6, 0x0e, 0x71, 0x93, 0x39, 0x1c, 0xe7, 0x93, 0x92, 0x1d, 0x90, 0x68, 0x15, 0x52, 0x36, 0x66, + 0x2d, 0xcf, 0xe9, 0x71, 0x87, 0x92, 0xfc, 0x8c, 0x5c, 0x8d, 0xb3, 0x84, 0x2c, 0x26, 0x56, 0xb3, + 0x8b, 0xed, 0xfc, 0xfc, 0xaa, 0xb6, 0x36, 0x6f, 0x04, 0x24, 0xfa, 0x18, 0xb2, 0xfb, 0x7d, 0x62, + 0x3b, 0xa4, 0x6d, 0x32, 0xee, 0x61, 0xcb, 0x65, 0xf9, 0xd9, 0xd5, 0xe9, 0xb5, 0x54, 0xf1, 0x9d, + 0xc2, 0x78, 0x67, 0x5a, 0xf8, 0xd0, 0x17, 0x6f, 0x48, 0x69, 0x63, 0x71, 0x3f, 0x4e, 0x32, 0xf4, + 0x3a, 0x64, 0x19, 0xfe, 0xa4, 0x8f, 0x49, 0x0b, 0x9b, 0x42, 0x1d, 0xf6, 0xf2, 0x73, 0xab, 0xda, + 0x5a, 0xc6, 0x58, 0x0c, 0xd8, 0xdb, 0x92, 0x8b, 0xee, 0xc1, 0x62, 0x9b, 0x1e, 0x60, 0x8f, 0x58, + 0x02, 0x2a, 0x1c, 0xb3, 0x20, 0xdd, 0x7c, 0xfd, 0xb9, 0x6e, 0xbe, 0x15, 0x8a, 0x08, 0x47, 0x67, + 0xda, 0x71, 0x52, 0x7f, 0x04, 0x99, 0xf0, 0x10, 0xef, 0x3a, 0x8c, 0xa3, 0x1d, 0x58, 0x3c, 0x08, + 0x18, 0xe2, 0x13, 0x2c, 0xaf, 0xc9, 0xbd, 0x8e, 0x7f, 0x94, 0x99, 0x50, 0xfe, 0x0e, 0x3e, 0x62, + 0xfa, 0xb3, 0x04, 0x64, 0x06, 0xf6, 0x8f, 0x1e, 0x01, 0x70, 0x6a, 0x5a, 0xb6, 0xed, 0x61, 0xc6, + 0x54, 0xa4, 0x7c, 0x30, 0x91, 0x2b, 0x0b, 0xbb, 0x74, 0xd3, 0x57, 0x73, 0x7b, 0xca, 0x58, 0xe0, + 0x01, 0x81, 0x18, 0x2c, 0x71, 0x6a, 0xb6, 0xa8, 0xeb, 0xf6, 0x89, 0x88, 0xc8, 0x1e, 0xa5, 0x5d, + 0x19, 0x44, 0xa9, 0x62, 0x75, 0xd2, 0x0f, 0x95, 0x03, 0x6d, 0x75, 0x4a, 0xbb, 0xb7, 0xa7, 0x8c, + 0x2c, 0x1f, 0x64, 0x2d, 0xdf, 0x84, 0x85, 0xd0, 0x1c, 0x11, 0x4d, 0xf1, 0x0d, 0x2e, 0x18, 0x01, + 0x89, 0x2e, 0xc2, 0xbc, 0x67, 0x71, 0x6c, 0x36, 0x7b, 0x4c, 0x9a, 0x94, 0x31, 0xe6, 0x04, 0x5d, + 0xea, 0xb1, 0xe5, 0x37, 0x21, 0x3b, 0xf4, 0x9d, 0xe7, 0xa0, 0x4b, 0x29, 0x58, 0xf0, 0x70, 0xcb, + 0xe9, 0x39, 0x98, 0x70, 0xfd, 0x1f, 0x1a, 0xcc, 0x1b, 0x16, 0xc7, 0x15, 0x8b, 0x5b, 0x2f, 0x37, + 0x19, 0xaf, 0x40, 0x0a, 0xf7, 0x68, 0xab, 0x63, 0x3a, 0xc4, 0xc6, 0x4f, 0xa4, 0x11, 0x49, 0x03, + 0x24, 0xab, 0x26, 0x38, 0xa8, 0x08, 0xe7, 0xa2, 0x88, 0xf1, 0xf0, 0xa1, 0xe5, 0xd9, 0xa6, 0xb0, + 0x51, 0xa6, 0x60, 0xd2, 0x38, 0x13, 0x2e, 0x1a, 0x72, 0x4d, 0x58, 0x89, 0xde, 0x85, 0x0b, 0x91, + 0x0c, 0x7e, 0xd2, 0xea, 0x58, 0xa4, 0x8d, 0x7d, 0xa9, 0x19, 0x29, 0x15, 0xa9, 0xac, 0xaa, 0x55, + 0x21, 0xa7, 0x7f, 0xa6, 0x41, 0xba, 0x64, 0x31, 0x1c, 0x6e, 0x75, 0xc8, 0x3a, 0xed, 0x98, 0x75, + 0x6b, 0x90, 0x6b, 0x5a, 0x0c, 0x0f, 0x18, 0xe6, 0xef, 0x61, 0x51, 0xf0, 0x63, 0x36, 0xbd, 0x09, + 0x48, 0x22, 0x07, 0xcd, 0x99, 0x96, 0x58, 0xa9, 0x63, 0xc0, 0x92, 0x2f, 0x12, 0x90, 0x0d, 0x33, + 0xa7, 0xc1, 0x2d, 0xde, 0x67, 0x2f, 0xd7, 0xef, 0x77, 0x61, 0x86, 0xf1, 0xc0, 0xda, 0x54, 0xf1, + 0xdd, 0x71, 0xe3, 0x76, 0xc0, 0x28, 0x6c, 0xf8, 0x4a, 0xd0, 0xab, 0x90, 0x3e, 0xa0, 0x5c, 0x94, + 0xb0, 0x1e, 0x3d, 0xc4, 0x9e, 0xda, 0x56, 0xca, 0xe7, 0xd5, 0x05, 0x0b, 0xfd, 0x10, 0x32, 0x4d, + 0x1a, 0x94, 0xb9, 0xe0, 0xfc, 0x52, 0xc5, 0xb7, 0xc7, 0xfd, 0x70, 0x89, 0xaa, 0x84, 0x11, 0x9f, + 0x4d, 0x37, 0x63, 0x94, 0xfe, 0x9b, 0x04, 0xa4, 0xe3, 0xcb, 0xe8, 0x47, 0xc1, 0xe6, 0x84, 0x8b, + 0x16, 0xc7, 0x4f, 0xca, 0xb8, 0x92, 0x01, 0xa2, 0x4a, 0xfa, 0x6e, 0xb0, 0xd7, 0xd7, 0x21, 0xdb, + 0x27, 0xc1, 0x56, 0x64, 0x28, 0x04, 0x27, 0x1e, 0xb2, 0xab, 0x82, 0xab, 0xff, 0x4a, 0x83, 0xdc, + 0xb0, 0x12, 0xa4, 0xc3, 0x4a, 0x69, 0x67, 0xbb, 0x52, 0xdb, 0xbe, 0x65, 0x36, 0x76, 0x37, 0x77, + 0xab, 0x66, 0x75, 0xfb, 0xfe, 0x96, 0x79, 0x7f, 0xbb, 0x51, 0xaf, 0x96, 0x6b, 0x1f, 0xd6, 0xaa, + 0x95, 0xdc, 0x14, 0xba, 0x0c, 0x17, 0x47, 0x60, 0x04, 0xab, 0x5a, 0xc9, 0x69, 0x68, 0x15, 0x2e, + 0x8d, 0x54, 0xa1, 0x98, 0xb9, 0x04, 0xba, 0x02, 0xaf, 0x9c, 0x88, 0xa8, 0x56, 0x72, 0xd3, 0xfa, + 0xdf, 0x12, 0xb0, 0x38, 0x78, 0x92, 0xc8, 0x1c, 0xf4, 0x59, 0x6d, 0xb2, 0x80, 0x18, 0x22, 0x63, + 0x7e, 0xd3, 0xff, 0xa9, 0x01, 0x3a, 0xbe, 0x8a, 0x5e, 0x83, 0xd5, 0x07, 0x9b, 0x77, 0x6b, 0x95, + 0xcd, 0xdd, 0x1d, 0xe3, 0x64, 0x97, 0xbc, 0x0a, 0x97, 0x47, 0xa2, 0x6a, 0xdb, 0x9b, 0xe5, 0xdd, + 0xda, 0x83, 0x6a, 0x4e, 0x13, 0x9b, 0x1e, 0x09, 0x51, 0x80, 0xc4, 0x89, 0x80, 0xef, 0x6f, 0xd6, + 0xee, 0x0a, 0xaf, 0xa0, 0xab, 0x70, 0x65, 0x24, 0x60, 0x77, 0x67, 0xab, 0xd4, 0xd8, 0xdd, 0xd9, + 0xae, 0x56, 0x72, 0xc9, 0x13, 0x2d, 0xa9, 0xd4, 0x1a, 0x9b, 0x25, 0xa1, 0x67, 0x46, 0xff, 0x34, + 0x11, 0xbb, 0xf6, 0x6a, 0x64, 0x9f, 0xa2, 0x1d, 0x58, 0x08, 0x2b, 0x8e, 0xca, 0xdb, 0x1b, 0xa7, + 0x76, 0xb0, 0x11, 0xe9, 0x40, 0x3b, 0x30, 0xcb, 0x64, 0x55, 0x50, 0xf9, 0xfb, 0xde, 0x44, 0xc7, + 0xd5, 0x67, 0x86, 0x52, 0x83, 0xb6, 0x60, 0x41, 0xde, 0x04, 0xb6, 0xc5, 0x2d, 0x99, 0xbe, 0xa9, + 0xe2, 0x5b, 0xe3, 0xea, 0x0c, 0xca, 0xa5, 0x21, 0x2f, 0x13, 0xf1, 0x4b, 0xff, 0x89, 0x06, 0x67, + 0xc2, 0x4f, 0x55, 0xf0, 0xbe, 0x43, 0x1c, 0xd9, 0x06, 0xbd, 0x74, 0x47, 0x5c, 0x84, 0x79, 0xab, + 0xcf, 0x3b, 0x26, 0x73, 0xda, 0xaa, 0x8f, 0x9b, 0x13, 0x74, 0xc3, 0x69, 0xeb, 0x9f, 0x27, 0x60, + 0xbe, 0xa2, 0xfa, 0x4d, 0xf4, 0x11, 0xa0, 0xe8, 0x4a, 0x08, 0x0a, 0xe1, 0xa9, 0x4b, 0xe8, 0x52, + 0xa8, 0x23, 0xe0, 0x7e, 0xf5, 0x05, 0x76, 0x27, 0xa8, 0x17, 0xd8, 0x36, 0x2d, 0x97, 0xf6, 0x09, + 0x57, 0xfe, 0xd5, 0x87, 0x3e, 0x2b, 0x9a, 0xe5, 0xf0, 0xab, 0x9b, 0x12, 0x19, 0xd4, 0x14, 0x6c, + 0xfb, 0x34, 0xda, 0x81, 0x25, 0xd5, 0x42, 0x3b, 0x94, 0x04, 0xea, 0x92, 0x63, 0xab, 0xcb, 0x45, + 0xc2, 0x3e, 0x47, 0xd4, 0x4e, 0x88, 0xda, 0xf2, 0xff, 0x9d, 0x9b, 0xae, 0xc3, 0x12, 0xe3, 0x96, + 0xc7, 0xcd, 0xe3, 0xce, 0xca, 0xca, 0x85, 0xea, 0xff, 0x8b, 0xc7, 0x9e, 0x40, 0x76, 0x68, 0x8e, + 0x41, 0x3b, 0x90, 0x6c, 0x52, 0x3b, 0xf0, 0xd3, 0xfb, 0xe3, 0x06, 0xf4, 0x90, 0x9a, 0x12, 0xb5, + 0x8f, 0x0c, 0xa9, 0x48, 0xcc, 0x44, 0x3d, 0x31, 0x1c, 0xa9, 0x90, 0xf6, 0x09, 0xfd, 0x8f, 0x09, + 0x38, 0x33, 0x42, 0xe6, 0x9b, 0x71, 0x68, 0x35, 0x98, 0xeb, 0x61, 0x62, 0x75, 0xf9, 0x91, 0x3a, + 0xac, 0xf5, 0x71, 0xdd, 0x50, 0xf7, 0xc5, 0x8c, 0x40, 0x1e, 0x7d, 0x2c, 0x5a, 0xa5, 0xae, 0x9c, + 0x42, 0x44, 0x93, 0xed, 0x70, 0x17, 0x87, 0x67, 0x36, 0xac, 0xd5, 0x9f, 0x58, 0xa3, 0x1b, 0xdc, + 0x97, 0x2b, 0x87, 0x62, 0xc6, 0x52, 0x73, 0x98, 0xa5, 0xff, 0x76, 0xfa, 0x98, 0x1f, 0xeb, 0x5d, + 0x8b, 0x7c, 0xe3, 0xfc, 0x98, 0x7c, 0x41, 0x3f, 0x6e, 0x41, 0x2e, 0xea, 0x54, 0x54, 0xe4, 0xcf, + 0x8c, 0x1d, 0xf9, 0x51, 0x97, 0xa3, 0x32, 0xe9, 0x0d, 0xd1, 0xeb, 0xfa, 0xc7, 0xd2, 0xec, 0x3a, + 0x72, 0x25, 0x3f, 0x2b, 0xe3, 0x33, 0xab, 0xf8, 0x25, 0xc5, 0x16, 0x6d, 0xb1, 0x0c, 0xd9, 0x10, + 0x68, 0xfa, 0x43, 0x67, 0xda, 0x58, 0x94, 0xfc, 0x00, 0x68, 0x8c, 0x40, 0x32, 0x39, 0x20, 0x0f, + 0x23, 0x1b, 0xfa, 0xef, 0x35, 0x58, 0xaa, 0x84, 0xc9, 0x58, 0x96, 0xbd, 0x32, 0x43, 0x86, 0x98, + 0xbc, 0x03, 0x66, 0x30, 0x4d, 0x8e, 0x7d, 0x73, 0x05, 0xd7, 0x83, 0x11, 0x57, 0x82, 0x7e, 0x00, + 0x99, 0x3e, 0x89, 0x6b, 0x4d, 0x48, 0xad, 0xc5, 0xd3, 0xe7, 0xb5, 0x31, 0xa8, 0x48, 0xef, 0xc2, + 0xec, 0xfd, 0x1e, 0x77, 0x5c, 0x8c, 0xbe, 0x05, 0xc8, 0x62, 0xa6, 0xdc, 0x37, 0x6d, 0x3d, 0x36, + 0x3b, 0xd8, 0x69, 0x77, 0xb8, 0x1a, 0x30, 0xb2, 0x16, 0xdb, 0xd9, 0x2f, 0x09, 0xfe, 0x6d, 0xc9, + 0x46, 0x97, 0x01, 0x0e, 0x1d, 0x62, 0xd3, 0x43, 0xb3, 0x8b, 0x89, 0x1a, 0xd4, 0x16, 0x7c, 0xce, + 0x5d, 0x4c, 0xd0, 0x79, 0x98, 0x6d, 0x3a, 0xfc, 0x00, 0xb7, 0x64, 0xe6, 0xa5, 0x0d, 0x45, 0xe9, + 0x1d, 0x38, 0x5b, 0xee, 0x7b, 0x1e, 0x26, 0xbc, 0x1c, 0x7b, 0xda, 0x60, 0xa8, 0x0e, 0x8b, 0x03, + 0x0f, 0x20, 0x81, 0xdb, 0xde, 0x78, 0x6e, 0x8c, 0xc7, 0x75, 0x18, 0x99, 0xf8, 0x63, 0x09, 0xd3, + 0xaf, 0xc0, 0x9c, 0x8a, 0xbe, 0x13, 0x9e, 0x73, 0x1e, 0xc0, 0xd9, 0x81, 0x8e, 0xc8, 0xc0, 0x9f, + 0xf4, 0x31, 0xe3, 0xe2, 0xfa, 0x6e, 0x75, 0x2c, 0x87, 0x98, 0x8e, 0x1d, 0x4c, 0xb2, 0x92, 0xae, + 0xd9, 0xe8, 0x2a, 0x64, 0x58, 0x87, 0x1e, 0x9a, 0x0e, 0xb1, 0x5a, 0xdc, 0x39, 0xf0, 0x27, 0x95, + 0x79, 0x23, 0x2d, 0x98, 0x35, 0xc5, 0xd3, 0xfb, 0x70, 0x6e, 0x48, 0x2f, 0xeb, 0x09, 0xcb, 0xd0, + 0x5e, 0xfc, 0xa1, 0xc1, 0x21, 0xfb, 0x54, 0xe5, 0xf1, 0x3b, 0xa7, 0xee, 0x36, 0xa4, 0xda, 0xe8, + 0xd5, 0x41, 0x90, 0xfa, 0xa7, 0x1a, 0x9c, 0x1f, 0xee, 0xa4, 0xbe, 0x7a, 0x47, 0xc3, 0x03, 0x5c, + 0xe2, 0x05, 0x06, 0x38, 0xfd, 0xc7, 0x70, 0xe1, 0x98, 0x05, 0x6a, 0xef, 0x51, 0x73, 0xa8, 0xbd, + 0x94, 0xe6, 0x50, 0xff, 0x8b, 0x16, 0xfb, 0x58, 0x50, 0x66, 0xbe, 0xde, 0xfd, 0x8e, 0xae, 0xa1, + 0xd3, 0xa3, 0x6b, 0xe8, 0x35, 0xc8, 0x62, 0x62, 0x0f, 0x20, 0xfd, 0xd7, 0x82, 0x0c, 0x26, 0x76, + 0x84, 0xd3, 0x31, 0xe4, 0x8f, 0x6f, 0x4b, 0x39, 0x31, 0x56, 0x87, 0xb5, 0x17, 0xab, 0xc3, 0xfa, + 0x4f, 0x35, 0x78, 0x45, 0x25, 0x62, 0xd4, 0xc3, 0x8a, 0xea, 0xf0, 0x35, 0x87, 0x8c, 0x0d, 0x97, + 0x46, 0x9b, 0xa1, 0xb6, 0x5c, 0x81, 0xa4, 0x6c, 0xff, 0xb5, 0x09, 0xdb, 0x7f, 0x29, 0xad, 0x7f, + 0x36, 0x0d, 0xd9, 0x86, 0x40, 0xd4, 0x2d, 0xcf, 0x72, 0x31, 0xc7, 0x1e, 0x13, 0x57, 0xc7, 0xd0, + 0xcc, 0xcc, 0x82, 0x5a, 0x37, 0x38, 0x34, 0x33, 0xf4, 0x36, 0x9c, 0xf7, 0x73, 0xdb, 0x8c, 0xf2, + 0xb7, 0xeb, 0xb8, 0x0e, 0x57, 0x17, 0xe6, 0x59, 0x7f, 0x35, 0xf6, 0xac, 0xe8, 0x3a, 0x7c, 0xe4, + 0x3b, 0xcc, 0xf4, 0xc8, 0x77, 0x98, 0x9b, 0x70, 0x89, 0x75, 0x2d, 0xd6, 0x91, 0x8f, 0x15, 0xfe, + 0x01, 0x99, 0xae, 0xc3, 0x9a, 0xb8, 0x63, 0x1d, 0x38, 0xd4, 0x53, 0x81, 0xb2, 0x1c, 0x60, 0xd4, + 0x61, 0x6e, 0x45, 0x08, 0xb4, 0x01, 0x17, 0x8f, 0x69, 0xb0, 0xe9, 0x21, 0x11, 0x75, 0x5d, 0xbd, + 0x2f, 0x5d, 0x18, 0x12, 0xaf, 0xa8, 0x65, 0xf4, 0x1e, 0xe4, 0x99, 0xd3, 0x26, 0xd8, 0xf6, 0xeb, + 0x3e, 0x33, 0x63, 0x75, 0x7d, 0xd6, 0x7f, 0x9a, 0xf2, 0xd7, 0x65, 0xf9, 0x67, 0x1f, 0x85, 0x35, + 0xbe, 0x08, 0xe7, 0x5c, 0x87, 0xb1, 0x48, 0xd0, 0xb5, 0x9e, 0x38, 0x6e, 0xdf, 0x95, 0xd7, 0x6a, + 0xd2, 0x38, 0xe3, 0x2f, 0xfa, 0x52, 0x5b, 0xfe, 0x92, 0xfe, 0x3b, 0x0d, 0x16, 0x6f, 0x61, 0x82, + 0x99, 0xc3, 0xca, 0x94, 0x70, 0x4c, 0x38, 0x7a, 0x08, 0x69, 0x79, 0x7a, 0x66, 0x4f, 0x1c, 0xce, + 0xa9, 0x0b, 0xc4, 0xd0, 0xb9, 0x1a, 0x29, 0x16, 0x32, 0x18, 0xba, 0x07, 0x10, 0x1e, 0x59, 0x70, + 0x67, 0x4e, 0x30, 0xdc, 0xc5, 0x94, 0x14, 0xff, 0x93, 0x84, 0xf4, 0xbd, 0x3e, 0xf6, 0x8e, 0x1a, + 0xd8, 0x3b, 0x70, 0x5a, 0x18, 0xfd, 0x4c, 0x1b, 0x1e, 0xad, 0xbf, 0x33, 0x59, 0x41, 0xf7, 0x53, + 0x6f, 0xf9, 0xbb, 0x13, 0x4a, 0xfb, 0x19, 0xf3, 0x96, 0x86, 0x7e, 0xa1, 0x1d, 0x7f, 0xa8, 0xfb, + 0xde, 0xa4, 0xf5, 0x56, 0x19, 0xf5, 0xc1, 0xc4, 0xf2, 0x2a, 0x91, 0x7f, 0xa9, 0x41, 0x6e, 0xb8, + 0xb0, 0xa1, 0xd3, 0x6b, 0x1d, 0xac, 0xf4, 0xcb, 0x37, 0x27, 0x57, 0xa0, 0xec, 0xfa, 0xb5, 0x16, + 0x76, 0x24, 0x03, 0x15, 0x08, 0x95, 0xc7, 0x55, 0xfd, 0x9c, 0x32, 0xba, 0x5c, 0x79, 0x31, 0x25, + 0xbe, 0x8d, 0xa5, 0x7f, 0x27, 0xfe, 0xf4, 0x74, 0x45, 0xfb, 0xf2, 0xe9, 0x8a, 0xf6, 0xf7, 0xa7, + 0x2b, 0xda, 0xcf, 0x9f, 0xad, 0x4c, 0x7d, 0xf9, 0x6c, 0x65, 0xea, 0xaf, 0xcf, 0x56, 0xa6, 0xe0, + 0x7a, 0x8b, 0xba, 0x63, 0x7e, 0xa3, 0x04, 0x7e, 0xaa, 0x78, 0x94, 0xd3, 0xba, 0xf6, 0xf0, 0x51, + 0xdb, 0xe1, 0x9d, 0x7e, 0x53, 0xc0, 0xd7, 0x5b, 0x94, 0xb9, 0x94, 0xad, 0x7b, 0xb8, 0x6b, 0x1d, + 0x61, 0x6f, 0xfd, 0xa0, 0x18, 0xfe, 0x94, 0x45, 0x9f, 0xad, 0x8f, 0xf7, 0xdf, 0xbf, 0xf7, 0x25, + 0x19, 0x50, 0x9f, 0x27, 0x92, 0xf5, 0x72, 0xb9, 0xf1, 0x45, 0xe2, 0x5a, 0x3d, 0xb0, 0xaf, 0x2c, + 0xec, 0x2b, 0x87, 0xf6, 0x49, 0x7b, 0x0a, 0x0f, 0x14, 0xfe, 0xcf, 0x11, 0x70, 0x4f, 0x00, 0xf7, + 0x42, 0xe0, 0x9e, 0x04, 0xee, 0x05, 0xc0, 0xa7, 0x89, 0xe2, 0x78, 0xc0, 0xbd, 0x5b, 0xf5, 0xd2, + 0x16, 0xe6, 0x96, 0xb8, 0x03, 0xfe, 0x95, 0xb8, 0x1e, 0x08, 0x6d, 0x6c, 0x08, 0x29, 0xf1, 0x57, + 0x89, 0x6d, 0x6c, 0x48, 0xb9, 0x8d, 0x8d, 0x40, 0xb0, 0x39, 0x2b, 0xff, 0x43, 0xf8, 0xed, 0xff, + 0x06, 0x00, 0x00, 0xff, 0xff, 0x89, 0x5e, 0xeb, 0x27, 0xf7, 0x1c, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + // Queries the current validator set, with filtering. + ValidatorInfo(ctx context.Context, in *ValidatorInfoRequest, opts ...grpc.CallOption) (QueryService_ValidatorInfoClient, error) + ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error) + ValidatorPenalty(ctx context.Context, in *ValidatorPenaltyRequest, opts ...grpc.CallOption) (*ValidatorPenaltyResponse, error) + CurrentValidatorRate(ctx context.Context, in *CurrentValidatorRateRequest, opts ...grpc.CallOption) (*CurrentValidatorRateResponse, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) ValidatorInfo(ctx context.Context, in *ValidatorInfoRequest, opts ...grpc.CallOption) (QueryService_ValidatorInfoClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorInfo", opts...) if err != nil { return nil, err } - return dAtA[:n], nil + x := &queryServiceValidatorInfoClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil } -func (m *BondingState) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type QueryService_ValidatorInfoClient interface { + Recv() (*ValidatorInfoResponse, error) + grpc.ClientStream } -func (m *BondingState) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XUnbondingEpoch != nil { - { - size := m.XUnbondingEpoch.Size() - i -= size - if _, err := m.XUnbondingEpoch.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } +type queryServiceValidatorInfoClient struct { + grpc.ClientStream +} + +func (x *queryServiceValidatorInfoClient) Recv() (*ValidatorInfoResponse, error) { + m := new(ValidatorInfoResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err } - if m.State != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.State)) - i-- - dAtA[i] = 0x8 + return m, nil +} + +func (c *queryServiceClient) ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error) { + out := new(ValidatorStatusResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorStatus", in, out, opts...) + if err != nil { + return nil, err } - return len(dAtA) - i, nil + return out, nil } -func (m *BondingState_UnbondingEpoch) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *queryServiceClient) ValidatorPenalty(ctx context.Context, in *ValidatorPenaltyRequest, opts ...grpc.CallOption) (*ValidatorPenaltyResponse, error) { + out := new(ValidatorPenaltyResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorPenalty", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *BondingState_UnbondingEpoch) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintStake(dAtA, i, uint64(m.UnbondingEpoch)) - i-- - dAtA[i] = 0x10 - return len(dAtA) - i, nil +func (c *queryServiceClient) CurrentValidatorRate(ctx context.Context, in *CurrentValidatorRateRequest, opts ...grpc.CallOption) (*CurrentValidatorRateResponse, error) { + out := new(CurrentValidatorRateResponse) + err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1alpha1.QueryService/CurrentValidatorRate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *ValidatorState) Marshal() (dAtA []byte, err error) { + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + // Queries the current validator set, with filtering. + ValidatorInfo(*ValidatorInfoRequest, QueryService_ValidatorInfoServer) error + ValidatorStatus(context.Context, *ValidatorStatusRequest) (*ValidatorStatusResponse, error) + ValidatorPenalty(context.Context, *ValidatorPenaltyRequest) (*ValidatorPenaltyResponse, error) + CurrentValidatorRate(context.Context, *CurrentValidatorRateRequest) (*CurrentValidatorRateResponse, error) +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) ValidatorInfo(req *ValidatorInfoRequest, srv QueryService_ValidatorInfoServer) error { + return status.Errorf(codes.Unimplemented, "method ValidatorInfo not implemented") +} +func (*UnimplementedQueryServiceServer) ValidatorStatus(ctx context.Context, req *ValidatorStatusRequest) (*ValidatorStatusResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ValidatorStatus not implemented") +} +func (*UnimplementedQueryServiceServer) ValidatorPenalty(ctx context.Context, req *ValidatorPenaltyRequest) (*ValidatorPenaltyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ValidatorPenalty not implemented") +} +func (*UnimplementedQueryServiceServer) CurrentValidatorRate(ctx context.Context, req *CurrentValidatorRateRequest) (*CurrentValidatorRateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CurrentValidatorRate not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_ValidatorInfo_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(ValidatorInfoRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).ValidatorInfo(m, &queryServiceValidatorInfoServer{stream}) +} + +type QueryService_ValidatorInfoServer interface { + Send(*ValidatorInfoResponse) error + grpc.ServerStream +} + +type queryServiceValidatorInfoServer struct { + grpc.ServerStream +} + +func (x *queryServiceValidatorInfoServer) Send(m *ValidatorInfoResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _QueryService_ValidatorStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ValidatorStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).ValidatorStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorStatus", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).ValidatorStatus(ctx, req.(*ValidatorStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_ValidatorPenalty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ValidatorPenaltyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).ValidatorPenalty(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorPenalty", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).ValidatorPenalty(ctx, req.(*ValidatorPenaltyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_CurrentValidatorRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CurrentValidatorRateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).CurrentValidatorRate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.core.component.stake.v1alpha1.QueryService/CurrentValidatorRate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).CurrentValidatorRate(ctx, req.(*CurrentValidatorRateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.core.component.stake.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ValidatorStatus", + Handler: _QueryService_ValidatorStatus_Handler, + }, + { + MethodName: "ValidatorPenalty", + Handler: _QueryService_ValidatorPenalty_Handler, + }, + { + MethodName: "CurrentValidatorRate", + Handler: _QueryService_CurrentValidatorRate_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "ValidatorInfo", + Handler: _QueryService_ValidatorInfo_Handler, + ServerStreams: true, + }, + }, + Metadata: "penumbra/core/component/stake/v1alpha1/stake.proto", +} + +func (m *ZKUndelegateClaimProof) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2099,25 +2471,27 @@ func (m *ValidatorState) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ValidatorState) MarshalTo(dAtA []byte) (int, error) { +func (m *ZKUndelegateClaimProof) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ValidatorState) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ZKUndelegateClaimProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.State != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.State)) + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintStake(dAtA, i, uint64(len(m.Inner))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ValidatorInfo) Marshal() (dAtA []byte, err error) { +func (m *Validator) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2127,19 +2501,19 @@ func (m *ValidatorInfo) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ValidatorInfo) MarshalTo(dAtA []byte) (int, error) { +func (m *Validator) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.RateData != nil { + if m.GovernanceKey != nil { { - size, err := m.RateData.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.GovernanceKey.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2147,23 +2521,68 @@ func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintStake(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a + dAtA[i] = 0x4a } - if m.Status != nil { - { - size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if m.Enabled { + i-- + if m.Enabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if m.SequenceNumber != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.SequenceNumber)) + i-- + dAtA[i] = 0x38 + } + if len(m.FundingStreams) > 0 { + for iNdEx := len(m.FundingStreams) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.FundingStreams[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 } + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintStake(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x2a + } + if len(m.Website) > 0 { + i -= len(m.Website) + copy(dAtA[i:], m.Website) + i = encodeVarintStake(dAtA, i, uint64(len(m.Website))) + i-- + dAtA[i] = 0x22 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintStake(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x1a + } + if len(m.ConsensusKey) > 0 { + i -= len(m.ConsensusKey) + copy(dAtA[i:], m.ConsensusKey) + i = encodeVarintStake(dAtA, i, uint64(len(m.ConsensusKey))) i-- dAtA[i] = 0x12 } - if m.Validator != nil { + if m.IdentityKey != nil { { - size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2176,7 +2595,7 @@ func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ValidatorDefinition) Marshal() (dAtA []byte, err error) { +func (m *ValidatorList) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2186,39 +2605,34 @@ func (m *ValidatorDefinition) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) { +func (m *ValidatorList) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ValidatorList) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.AuthSig) > 0 { - i -= len(m.AuthSig) - copy(dAtA[i:], m.AuthSig) - i = encodeVarintStake(dAtA, i, uint64(len(m.AuthSig))) - i-- - dAtA[i] = 0x12 - } - if m.Validator != nil { - { - size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.ValidatorKeys) > 0 { + for iNdEx := len(m.ValidatorKeys) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ValidatorKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *Delegate) Marshal() (dAtA []byte, err error) { +func (m *FundingStream) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2228,31 +2642,38 @@ func (m *Delegate) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Delegate) MarshalTo(dAtA []byte) (int, error) { +func (m *FundingStream) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *FundingStream) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DelegationAmount != nil { + if m.Recipient != nil { { - size, err := m.DelegationAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { + size := m.Recipient.Size() + i -= size + if _, err := m.Recipient.MarshalTo(dAtA[i:]); err != nil { return 0, err } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) } - i-- - dAtA[i] = 0x22 } - if m.UnbondedAmount != nil { + return len(dAtA) - i, nil +} + +func (m *FundingStream_ToAddress_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FundingStream_ToAddress_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ToAddress != nil { { - size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ToAddress.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2260,16 +2681,20 @@ func (m *Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintStake(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a - } - if m.EpochIndex != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex)) - i-- - dAtA[i] = 0x10 + dAtA[i] = 0xa } - if m.ValidatorIdentity != nil { + return len(dAtA) - i, nil +} +func (m *FundingStream_ToCommunityPool_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FundingStream_ToCommunityPool_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ToCommunityPool != nil { { - size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ToCommunityPool.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2277,12 +2702,11 @@ func (m *Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintStake(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x12 } return len(dAtA) - i, nil } - -func (m *Undelegate) Marshal() (dAtA []byte, err error) { +func (m *FundingStream_ToAddress) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2292,61 +2716,32 @@ func (m *Undelegate) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Undelegate) MarshalTo(dAtA []byte) (int, error) { +func (m *FundingStream_ToAddress) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *FundingStream_ToAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DelegationAmount != nil { - { - size, err := m.DelegationAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.UnbondedAmount != nil { - { - size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.StartEpochIndex != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex)) + if m.RateBps != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.RateBps)) i-- dAtA[i] = 0x10 } - if m.ValidatorIdentity != nil { - { - size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintStake(dAtA, i, uint64(len(m.Address))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *UndelegateClaim) Marshal() (dAtA []byte, err error) { +func (m *FundingStream_ToCommunityPool) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2356,39 +2751,25 @@ func (m *UndelegateClaim) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *UndelegateClaim) MarshalTo(dAtA []byte) (int, error) { +func (m *FundingStream_ToCommunityPool) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *FundingStream_ToCommunityPool) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Proof) > 0 { - i -= len(m.Proof) - copy(dAtA[i:], m.Proof) - i = encodeVarintStake(dAtA, i, uint64(len(m.Proof))) - i-- - dAtA[i] = 0x12 - } - if m.Body != nil { - { - size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } + if m.RateBps != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.RateBps)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x10 } return len(dAtA) - i, nil } -func (m *UndelegateClaimBody) Marshal() (dAtA []byte, err error) { +func (m *RateData) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2398,48 +2779,34 @@ func (m *UndelegateClaimBody) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *UndelegateClaimBody) MarshalTo(dAtA []byte) (int, error) { +func (m *RateData) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *UndelegateClaimBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RateData) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.BalanceCommitment != nil { - { - size, err := m.BalanceCommitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } + if m.ValidatorExchangeRate != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.ValidatorExchangeRate)) i-- - dAtA[i] = 0x22 + dAtA[i] = 0x28 } - if m.Penalty != nil { - { - size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } + if m.ValidatorRewardRate != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.ValidatorRewardRate)) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x20 } - if m.StartEpochIndex != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex)) + if m.EpochIndex != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex)) i-- dAtA[i] = 0x10 } - if m.ValidatorIdentity != nil { + if m.IdentityKey != nil { { - size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2452,7 +2819,7 @@ func (m *UndelegateClaimBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *UndelegateClaimPlan) Marshal() (dAtA []byte, err error) { +func (m *BaseRateData) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2462,40 +2829,57 @@ func (m *UndelegateClaimPlan) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *UndelegateClaimPlan) MarshalTo(dAtA []byte) (int, error) { +func (m *BaseRateData) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *BaseRateData) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.ProofBlindingS) > 0 { - i -= len(m.ProofBlindingS) - copy(dAtA[i:], m.ProofBlindingS) - i = encodeVarintStake(dAtA, i, uint64(len(m.ProofBlindingS))) + if m.BaseExchangeRate != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.BaseExchangeRate)) i-- - dAtA[i] = 0x42 + dAtA[i] = 0x18 } - if len(m.ProofBlindingR) > 0 { - i -= len(m.ProofBlindingR) - copy(dAtA[i:], m.ProofBlindingR) - i = encodeVarintStake(dAtA, i, uint64(len(m.ProofBlindingR))) + if m.BaseRewardRate != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.BaseRewardRate)) i-- - dAtA[i] = 0x3a + dAtA[i] = 0x10 } - if len(m.BalanceBlinding) > 0 { - i -= len(m.BalanceBlinding) - copy(dAtA[i:], m.BalanceBlinding) - i = encodeVarintStake(dAtA, i, uint64(len(m.BalanceBlinding))) + if m.EpochIndex != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex)) i-- - dAtA[i] = 0x32 + dAtA[i] = 0x8 } - if m.UnbondingAmount != nil { + return len(dAtA) - i, nil +} + +func (m *ValidatorStatus) 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 *ValidatorStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.BondingState != nil { { - size, err := m.UnbondingAmount.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.BondingState.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2503,11 +2887,16 @@ func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintStake(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x2a + dAtA[i] = 0x22 } - if m.Penalty != nil { + if m.VotingPower != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.VotingPower)) + i-- + dAtA[i] = 0x18 + } + if m.State != nil { { - size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2515,16 +2904,11 @@ func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintStake(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x22 - } - if m.StartEpochIndex != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex)) - i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if m.ValidatorIdentity != nil { + if m.IdentityKey != nil { { - size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2537,7 +2921,7 @@ func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *DelegationChanges) Marshal() (dAtA []byte, err error) { +func (m *BondingState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2547,48 +2931,30 @@ func (m *DelegationChanges) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DelegationChanges) MarshalTo(dAtA []byte) (int, error) { +func (m *BondingState) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DelegationChanges) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *BondingState) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Undelegations) > 0 { - for iNdEx := len(m.Undelegations) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Undelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } + if m.UnbondingEpoch != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.UnbondingEpoch)) + i-- + dAtA[i] = 0x10 } - if len(m.Delegations) > 0 { - for iNdEx := len(m.Delegations) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Delegations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } + if m.State != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *Uptime) Marshal() (dAtA []byte, err error) { +func (m *ValidatorState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2598,37 +2964,25 @@ func (m *Uptime) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Uptime) MarshalTo(dAtA []byte) (int, error) { +func (m *ValidatorState) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Uptime) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ValidatorState) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Bitvec) > 0 { - i -= len(m.Bitvec) - copy(dAtA[i:], m.Bitvec) - i = encodeVarintStake(dAtA, i, uint64(len(m.Bitvec))) - i-- - dAtA[i] = 0x1a - } - if m.WindowLen != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.WindowLen)) - i-- - dAtA[i] = 0x10 - } - if m.AsOfBlockHeight != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.AsOfBlockHeight)) + if m.State != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.State)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *CurrentConsensusKeys) Marshal() (dAtA []byte, err error) { +func (m *ValidatorInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2638,34 +2992,56 @@ func (m *CurrentConsensusKeys) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *CurrentConsensusKeys) MarshalTo(dAtA []byte) (int, error) { +func (m *ValidatorInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CurrentConsensusKeys) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.ConsensusKeys) > 0 { - for iNdEx := len(m.ConsensusKeys) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.ConsensusKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintStake(dAtA, i, uint64(size)) + if m.RateData != nil { + { + size, err := m.RateData.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0xa + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x1a + } + if m.Status != nil { + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Validator != nil { + { + size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *Penalty) Marshal() (dAtA []byte, err error) { +func (m *ValidatorDefinition) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2675,496 +3051,2372 @@ func (m *Penalty) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Penalty) MarshalTo(dAtA []byte) (int, error) { +func (m *ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Penalty) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Inner != 0 { - i = encodeVarintStake(dAtA, i, uint64(m.Inner)) + if len(m.AuthSig) > 0 { + i -= len(m.AuthSig) + copy(dAtA[i:], m.AuthSig) + i = encodeVarintStake(dAtA, i, uint64(len(m.AuthSig))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x12 + } + if m.Validator != nil { + { + size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func encodeVarintStake(dAtA []byte, offset int, v uint64) int { - offset -= sovStake(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *Delegate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *Validator) Size() (n int) { - if m == nil { - return 0 - } + +func (m *Delegate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.IdentityKey != nil { - l = m.IdentityKey.Size() - n += 1 + l + sovStake(uint64(l)) + if m.DelegationAmount != nil { + { + size, err := m.DelegationAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - l = len(m.ConsensusKey) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) - } - l = len(m.Name) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) - } - l = len(m.Website) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) - } - l = len(m.Description) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) - } - if len(m.FundingStreams) > 0 { - for _, e := range m.FundingStreams { - l = e.Size() - n += 1 + l + sovStake(uint64(l)) + if m.UnbondedAmount != nil { + { + size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x1a } - if m.SequenceNumber != 0 { - n += 1 + sovStake(uint64(m.SequenceNumber)) - } - if m.Enabled { - n += 2 - } - if m.GovernanceKey != nil { - l = m.GovernanceKey.Size() - n += 1 + l + sovStake(uint64(l)) - } - return n -} - -func (m *ValidatorList) Size() (n int) { - if m == nil { - return 0 + if m.EpochIndex != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex)) + i-- + dAtA[i] = 0x10 } - var l int - _ = l - if len(m.ValidatorKeys) > 0 { - for _, e := range m.ValidatorKeys { - l = e.Size() - n += 1 + l + sovStake(uint64(l)) + if m.ValidatorIdentity != nil { + { + size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *FundingStream) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Recipient != nil { - n += m.Recipient.Size() +func (m *Undelegate) 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 n + return dAtA[:n], nil } -func (m *FundingStream_ToAddress_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ToAddress != nil { - l = m.ToAddress.Size() - n += 1 + l + sovStake(uint64(l)) - } - return n +func (m *Undelegate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FundingStream_ToDao_) Size() (n int) { - if m == nil { - return 0 - } + +func (m *Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ToDao != nil { - l = m.ToDao.Size() - n += 1 + l + sovStake(uint64(l)) + if m.DelegationAmount != nil { + { + size, err := m.DelegationAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - return n -} -func (m *FundingStream_ToAddress) Size() (n int) { - if m == nil { - return 0 + if m.UnbondedAmount != nil { + { + size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - var l int - _ = l - l = len(m.Address) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) + if m.StartEpochIndex != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex)) + i-- + dAtA[i] = 0x10 } - if m.RateBps != 0 { - n += 1 + sovStake(uint64(m.RateBps)) + if m.ValidatorIdentity != nil { + { + size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *FundingStream_ToDao) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.RateBps != 0 { - n += 1 + sovStake(uint64(m.RateBps)) +func (m *UndelegateClaim) 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 n + return dAtA[:n], nil } -func (m *RateData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.IdentityKey != nil { - l = m.IdentityKey.Size() - n += 1 + l + sovStake(uint64(l)) - } - if m.EpochIndex != 0 { - n += 1 + sovStake(uint64(m.EpochIndex)) - } - if m.ValidatorRewardRate != 0 { - n += 1 + sovStake(uint64(m.ValidatorRewardRate)) - } - if m.ValidatorExchangeRate != 0 { - n += 1 + sovStake(uint64(m.ValidatorExchangeRate)) - } - return n +func (m *UndelegateClaim) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BaseRateData) Size() (n int) { - if m == nil { - return 0 - } +func (m *UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.EpochIndex != 0 { - n += 1 + sovStake(uint64(m.EpochIndex)) - } - if m.BaseRewardRate != 0 { - n += 1 + sovStake(uint64(m.BaseRewardRate)) + if len(m.Proof) > 0 { + i -= len(m.Proof) + copy(dAtA[i:], m.Proof) + i = encodeVarintStake(dAtA, i, uint64(len(m.Proof))) + i-- + dAtA[i] = 0x12 } - if m.BaseExchangeRate != 0 { - n += 1 + sovStake(uint64(m.BaseExchangeRate)) + if m.Body != nil { + { + size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *ValidatorStatus) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.IdentityKey != nil { - l = m.IdentityKey.Size() - n += 1 + l + sovStake(uint64(l)) - } - if m.State != nil { - l = m.State.Size() - n += 1 + l + sovStake(uint64(l)) - } - if m.VotingPower != 0 { - n += 1 + sovStake(uint64(m.VotingPower)) - } - if m.BondingState != nil { - l = m.BondingState.Size() - n += 1 + l + sovStake(uint64(l)) +func (m *UndelegateClaimBody) 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 n + return dAtA[:n], nil } -func (m *BondingState) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.State != 0 { - n += 1 + sovStake(uint64(m.State)) - } - if m.XUnbondingEpoch != nil { - n += m.XUnbondingEpoch.Size() - } - return n +func (m *UndelegateClaimBody) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BondingState_UnbondingEpoch) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - n += 1 + sovStake(uint64(m.UnbondingEpoch)) - return n -} -func (m *ValidatorState) Size() (n int) { - if m == nil { - return 0 - } +func (m *UndelegateClaimBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.State != 0 { - n += 1 + sovStake(uint64(m.State)) - } - return n -} - -func (m *ValidatorInfo) Size() (n int) { - if m == nil { - return 0 + if m.BalanceCommitment != nil { + { + size, err := m.BalanceCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - var l int - _ = l - if m.Validator != nil { - l = m.Validator.Size() - n += 1 + l + sovStake(uint64(l)) + if m.Penalty != nil { + { + size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - if m.Status != nil { - l = m.Status.Size() - n += 1 + l + sovStake(uint64(l)) + if m.StartEpochIndex != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex)) + i-- + dAtA[i] = 0x10 } - if m.RateData != nil { - l = m.RateData.Size() - n += 1 + l + sovStake(uint64(l)) + if m.ValidatorIdentity != nil { + { + size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *ValidatorDefinition) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Validator != nil { - l = m.Validator.Size() - n += 1 + l + sovStake(uint64(l)) - } - l = len(m.AuthSig) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) +func (m *UndelegateClaimPlan) 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 n + return dAtA[:n], nil } -func (m *Delegate) Size() (n int) { - if m == nil { - return 0 - } +func (m *UndelegateClaimPlan) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ValidatorIdentity != nil { - l = m.ValidatorIdentity.Size() - n += 1 + l + sovStake(uint64(l)) - } - if m.EpochIndex != 0 { - n += 1 + sovStake(uint64(m.EpochIndex)) + if len(m.ProofBlindingS) > 0 { + i -= len(m.ProofBlindingS) + copy(dAtA[i:], m.ProofBlindingS) + i = encodeVarintStake(dAtA, i, uint64(len(m.ProofBlindingS))) + i-- + dAtA[i] = 0x42 } - if m.UnbondedAmount != nil { - l = m.UnbondedAmount.Size() - n += 1 + l + sovStake(uint64(l)) + if len(m.ProofBlindingR) > 0 { + i -= len(m.ProofBlindingR) + copy(dAtA[i:], m.ProofBlindingR) + i = encodeVarintStake(dAtA, i, uint64(len(m.ProofBlindingR))) + i-- + dAtA[i] = 0x3a } - if m.DelegationAmount != nil { - l = m.DelegationAmount.Size() - n += 1 + l + sovStake(uint64(l)) + if len(m.BalanceBlinding) > 0 { + i -= len(m.BalanceBlinding) + copy(dAtA[i:], m.BalanceBlinding) + i = encodeVarintStake(dAtA, i, uint64(len(m.BalanceBlinding))) + i-- + dAtA[i] = 0x32 } - return n -} - -func (m *Undelegate) Size() (n int) { - if m == nil { - return 0 + if m.UnbondingAmount != nil { + { + size, err := m.UnbondingAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a } - var l int - _ = l - if m.ValidatorIdentity != nil { - l = m.ValidatorIdentity.Size() - n += 1 + l + sovStake(uint64(l)) + if m.Penalty != nil { + { + size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } if m.StartEpochIndex != 0 { - n += 1 + sovStake(uint64(m.StartEpochIndex)) - } - if m.UnbondedAmount != nil { - l = m.UnbondedAmount.Size() - n += 1 + l + sovStake(uint64(l)) + i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex)) + i-- + dAtA[i] = 0x10 } - if m.DelegationAmount != nil { - l = m.DelegationAmount.Size() - n += 1 + l + sovStake(uint64(l)) + if m.ValidatorIdentity != nil { + { + size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *UndelegateClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Body != nil { - l = m.Body.Size() - n += 1 + l + sovStake(uint64(l)) - } - l = len(m.Proof) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) +func (m *DelegationChanges) 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 n + return dAtA[:n], nil } -func (m *UndelegateClaimBody) Size() (n int) { - if m == nil { - return 0 - } +func (m *DelegationChanges) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegationChanges) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ValidatorIdentity != nil { - l = m.ValidatorIdentity.Size() - n += 1 + l + sovStake(uint64(l)) - } - if m.StartEpochIndex != 0 { - n += 1 + sovStake(uint64(m.StartEpochIndex)) + if len(m.Undelegations) > 0 { + for iNdEx := len(m.Undelegations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Undelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - if m.Penalty != nil { - l = m.Penalty.Size() - n += 1 + l + sovStake(uint64(l)) - } - if m.BalanceCommitment != nil { - l = m.BalanceCommitment.Size() - n += 1 + l + sovStake(uint64(l)) + if len(m.Delegations) > 0 { + for iNdEx := len(m.Delegations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Delegations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } - return n + return len(dAtA) - i, nil } -func (m *UndelegateClaimPlan) Size() (n int) { - if m == nil { - return 0 +func (m *Uptime) 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 *Uptime) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Uptime) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ValidatorIdentity != nil { - l = m.ValidatorIdentity.Size() - n += 1 + l + sovStake(uint64(l)) + if len(m.Bitvec) > 0 { + i -= len(m.Bitvec) + copy(dAtA[i:], m.Bitvec) + i = encodeVarintStake(dAtA, i, uint64(len(m.Bitvec))) + i-- + dAtA[i] = 0x1a } - if m.StartEpochIndex != 0 { - n += 1 + sovStake(uint64(m.StartEpochIndex)) + if m.WindowLen != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.WindowLen)) + i-- + dAtA[i] = 0x10 } - if m.Penalty != nil { - l = m.Penalty.Size() - n += 1 + l + sovStake(uint64(l)) + if m.AsOfBlockHeight != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.AsOfBlockHeight)) + i-- + dAtA[i] = 0x8 } - if m.UnbondingAmount != nil { - l = m.UnbondingAmount.Size() - n += 1 + l + sovStake(uint64(l)) + return len(dAtA) - i, nil +} + +func (m *CurrentConsensusKeys) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - l = len(m.BalanceBlinding) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) + return dAtA[:n], nil +} + +func (m *CurrentConsensusKeys) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CurrentConsensusKeys) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ConsensusKeys) > 0 { + for iNdEx := len(m.ConsensusKeys) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ConsensusKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } - l = len(m.ProofBlindingR) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) + return len(dAtA) - i, nil +} + +func (m *Penalty) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - l = len(m.ProofBlindingS) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) + return dAtA[:n], nil +} + +func (m *Penalty) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Penalty) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintStake(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *DelegationChanges) Size() (n int) { - if m == nil { - return 0 +func (m *ValidatorInfoRequest) 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 *ValidatorInfoRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.Delegations) > 0 { - for _, e := range m.Delegations { - l = e.Size() - n += 1 + l + sovStake(uint64(l)) + if m.ShowInactive { + i-- + if m.ShowInactive { + dAtA[i] = 1 + } else { + dAtA[i] = 0 } + i-- + dAtA[i] = 0x10 } - if len(m.Undelegations) > 0 { - for _, e := range m.Undelegations { - l = e.Size() - n += 1 + l + sovStake(uint64(l)) - } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintStake(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *Uptime) Size() (n int) { - if m == nil { - return 0 +func (m *ValidatorInfoResponse) 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 *ValidatorInfoResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.AsOfBlockHeight != 0 { - n += 1 + sovStake(uint64(m.AsOfBlockHeight)) - } - if m.WindowLen != 0 { - n += 1 + sovStake(uint64(m.WindowLen)) - } - l = len(m.Bitvec) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) + if m.ValidatorInfo != nil { + { + size, err := m.ValidatorInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *CurrentConsensusKeys) Size() (n int) { - if m == nil { - return 0 +func (m *ValidatorStatusRequest) 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 *ValidatorStatusRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.ConsensusKeys) > 0 { - for _, e := range m.ConsensusKeys { - l = e.Size() - n += 1 + l + sovStake(uint64(l)) + if m.IdentityKey != nil { + { + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x12 } - return n + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintStake(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *Penalty) Size() (n int) { - if m == nil { - return 0 +func (m *ValidatorStatusResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - if m.Inner != 0 { - n += 1 + sovStake(uint64(m.Inner)) + return dAtA[:n], nil +} + +func (m *ValidatorStatusResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Status != nil { + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorPenaltyRequest) 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 *ValidatorPenaltyRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorPenaltyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EndEpochIndex != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.EndEpochIndex)) + i-- + dAtA[i] = 0x20 + } + if m.StartEpochIndex != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex)) + i-- + dAtA[i] = 0x18 + } + if m.IdentityKey != nil { + { + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintStake(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorPenaltyResponse) 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 *ValidatorPenaltyResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorPenaltyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Penalty != nil { + { + size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CurrentValidatorRateRequest) 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 *CurrentValidatorRateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CurrentValidatorRateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IdentityKey != nil { + { + size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintStake(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CurrentValidatorRateResponse) 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 *CurrentValidatorRateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CurrentValidatorRateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Data != nil { + { + size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StakeParameters) 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 *StakeParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StakeParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.MissedBlocksMaximum != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.MissedBlocksMaximum)) + i-- + dAtA[i] = 0x38 + } + if m.SignedBlocksWindowLen != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.SignedBlocksWindowLen)) + i-- + dAtA[i] = 0x30 + } + if m.SlashingPenaltyDowntime != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.SlashingPenaltyDowntime)) + i-- + dAtA[i] = 0x28 + } + if m.SlashingPenaltyMisbehavior != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.SlashingPenaltyMisbehavior)) + i-- + dAtA[i] = 0x20 + } + if m.BaseRewardRate != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.BaseRewardRate)) + i-- + dAtA[i] = 0x18 + } + if m.ActiveValidatorLimit != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.ActiveValidatorLimit)) + i-- + dAtA[i] = 0x10 + } + if m.UnbondingEpochs != 0 { + i = encodeVarintStake(dAtA, i, uint64(m.UnbondingEpochs)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisContent) 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 *GenesisContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Validators) > 0 { + for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.StakeParams != nil { + { + size, err := m.StakeParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStake(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintStake(dAtA []byte, offset int, v uint64) int { + offset -= sovStake(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ZKUndelegateClaimProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *Validator) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovStake(uint64(l)) + } + l = len(m.ConsensusKey) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + l = len(m.Website) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + if len(m.FundingStreams) > 0 { + for _, e := range m.FundingStreams { + l = e.Size() + n += 1 + l + sovStake(uint64(l)) + } + } + if m.SequenceNumber != 0 { + n += 1 + sovStake(uint64(m.SequenceNumber)) + } + if m.Enabled { + n += 2 + } + if m.GovernanceKey != nil { + l = m.GovernanceKey.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *ValidatorList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ValidatorKeys) > 0 { + for _, e := range m.ValidatorKeys { + l = e.Size() + n += 1 + l + sovStake(uint64(l)) + } + } + return n +} + +func (m *FundingStream) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Recipient != nil { + n += m.Recipient.Size() + } + return n +} + +func (m *FundingStream_ToAddress_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ToAddress != nil { + l = m.ToAddress.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} +func (m *FundingStream_ToCommunityPool_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ToCommunityPool != nil { + l = m.ToCommunityPool.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} +func (m *FundingStream_ToAddress) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + if m.RateBps != 0 { + n += 1 + sovStake(uint64(m.RateBps)) + } + return n +} + +func (m *FundingStream_ToCommunityPool) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RateBps != 0 { + n += 1 + sovStake(uint64(m.RateBps)) + } + return n +} + +func (m *RateData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.EpochIndex != 0 { + n += 1 + sovStake(uint64(m.EpochIndex)) + } + if m.ValidatorRewardRate != 0 { + n += 1 + sovStake(uint64(m.ValidatorRewardRate)) + } + if m.ValidatorExchangeRate != 0 { + n += 1 + sovStake(uint64(m.ValidatorExchangeRate)) + } + return n +} + +func (m *BaseRateData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EpochIndex != 0 { + n += 1 + sovStake(uint64(m.EpochIndex)) + } + if m.BaseRewardRate != 0 { + n += 1 + sovStake(uint64(m.BaseRewardRate)) + } + if m.BaseExchangeRate != 0 { + n += 1 + sovStake(uint64(m.BaseExchangeRate)) + } + return n +} + +func (m *ValidatorStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.State != nil { + l = m.State.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.VotingPower != 0 { + n += 1 + sovStake(uint64(m.VotingPower)) + } + if m.BondingState != nil { + l = m.BondingState.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *BondingState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.State != 0 { + n += 1 + sovStake(uint64(m.State)) + } + if m.UnbondingEpoch != 0 { + n += 1 + sovStake(uint64(m.UnbondingEpoch)) + } + return n +} + +func (m *ValidatorState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.State != 0 { + n += 1 + sovStake(uint64(m.State)) + } + return n +} + +func (m *ValidatorInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Validator != nil { + l = m.Validator.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.Status != nil { + l = m.Status.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.RateData != nil { + l = m.RateData.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *ValidatorDefinition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Validator != nil { + l = m.Validator.Size() + n += 1 + l + sovStake(uint64(l)) + } + l = len(m.AuthSig) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *Delegate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValidatorIdentity != nil { + l = m.ValidatorIdentity.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.EpochIndex != 0 { + n += 1 + sovStake(uint64(m.EpochIndex)) + } + if m.UnbondedAmount != nil { + l = m.UnbondedAmount.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.DelegationAmount != nil { + l = m.DelegationAmount.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *Undelegate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValidatorIdentity != nil { + l = m.ValidatorIdentity.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.StartEpochIndex != 0 { + n += 1 + sovStake(uint64(m.StartEpochIndex)) + } + if m.UnbondedAmount != nil { + l = m.UnbondedAmount.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.DelegationAmount != nil { + l = m.DelegationAmount.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *UndelegateClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Body != nil { + l = m.Body.Size() + n += 1 + l + sovStake(uint64(l)) + } + l = len(m.Proof) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *UndelegateClaimBody) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValidatorIdentity != nil { + l = m.ValidatorIdentity.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.StartEpochIndex != 0 { + n += 1 + sovStake(uint64(m.StartEpochIndex)) + } + if m.Penalty != nil { + l = m.Penalty.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.BalanceCommitment != nil { + l = m.BalanceCommitment.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *UndelegateClaimPlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValidatorIdentity != nil { + l = m.ValidatorIdentity.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.StartEpochIndex != 0 { + n += 1 + sovStake(uint64(m.StartEpochIndex)) + } + if m.Penalty != nil { + l = m.Penalty.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.UnbondingAmount != nil { + l = m.UnbondingAmount.Size() + n += 1 + l + sovStake(uint64(l)) + } + l = len(m.BalanceBlinding) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + l = len(m.ProofBlindingR) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + l = len(m.ProofBlindingS) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *DelegationChanges) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Delegations) > 0 { + for _, e := range m.Delegations { + l = e.Size() + n += 1 + l + sovStake(uint64(l)) + } + } + if len(m.Undelegations) > 0 { + for _, e := range m.Undelegations { + l = e.Size() + n += 1 + l + sovStake(uint64(l)) + } + } + return n +} + +func (m *Uptime) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AsOfBlockHeight != 0 { + n += 1 + sovStake(uint64(m.AsOfBlockHeight)) + } + if m.WindowLen != 0 { + n += 1 + sovStake(uint64(m.WindowLen)) + } + l = len(m.Bitvec) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *CurrentConsensusKeys) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ConsensusKeys) > 0 { + for _, e := range m.ConsensusKeys { + l = e.Size() + n += 1 + l + sovStake(uint64(l)) + } + } + return n +} + +func (m *Penalty) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *ValidatorInfoRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + if m.ShowInactive { + n += 2 + } + return n +} + +func (m *ValidatorInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValidatorInfo != nil { + l = m.ValidatorInfo.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *ValidatorStatusRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *ValidatorStatusResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Status != nil { + l = m.Status.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *ValidatorPenaltyRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovStake(uint64(l)) + } + if m.StartEpochIndex != 0 { + n += 1 + sovStake(uint64(m.StartEpochIndex)) + } + if m.EndEpochIndex != 0 { + n += 1 + sovStake(uint64(m.EndEpochIndex)) + } + return n +} + +func (m *ValidatorPenaltyResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Penalty != nil { + l = m.Penalty.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *CurrentValidatorRateRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovStake(uint64(l)) + } + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *CurrentValidatorRateResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.Size() + n += 1 + l + sovStake(uint64(l)) + } + return n +} + +func (m *StakeParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UnbondingEpochs != 0 { + n += 1 + sovStake(uint64(m.UnbondingEpochs)) + } + if m.ActiveValidatorLimit != 0 { + n += 1 + sovStake(uint64(m.ActiveValidatorLimit)) + } + if m.BaseRewardRate != 0 { + n += 1 + sovStake(uint64(m.BaseRewardRate)) + } + if m.SlashingPenaltyMisbehavior != 0 { + n += 1 + sovStake(uint64(m.SlashingPenaltyMisbehavior)) + } + if m.SlashingPenaltyDowntime != 0 { + n += 1 + sovStake(uint64(m.SlashingPenaltyDowntime)) + } + if m.SignedBlocksWindowLen != 0 { + n += 1 + sovStake(uint64(m.SignedBlocksWindowLen)) + } + if m.MissedBlocksMaximum != 0 { + n += 1 + sovStake(uint64(m.MissedBlocksMaximum)) + } + return n +} + +func (m *GenesisContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StakeParams != nil { + l = m.StakeParams.Size() + n += 1 + l + sovStake(uint64(l)) + } + if len(m.Validators) > 0 { + for _, e := range m.Validators { + l = e.Size() + n += 1 + l + sovStake(uint64(l)) + } + } + return n +} + +func sovStake(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozStake(x uint64) (n int) { + return sovStake(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ZKUndelegateClaimProof) 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 ErrIntOverflowStake + } + 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: ZKUndelegateClaimProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZKUndelegateClaimProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Validator) 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 ErrIntOverflowStake + } + 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: Validator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.IdentityKey == nil { + m.IdentityKey = &v1alpha1.IdentityKey{} + } + if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConsensusKey = append(m.ConsensusKey[:0], dAtA[iNdEx:postIndex]...) + if m.ConsensusKey == nil { + m.ConsensusKey = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + 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 ErrInvalidLengthStake + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Website", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + 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 ErrInvalidLengthStake + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Website = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + 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 ErrInvalidLengthStake + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FundingStreams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FundingStreams = append(m.FundingStreams, &FundingStream{}) + if err := m.FundingStreams[len(m.FundingStreams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType) + } + m.SequenceNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SequenceNumber |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Enabled = bool(v != 0) + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GovernanceKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GovernanceKey == nil { + m.GovernanceKey = &v1alpha1.GovernanceKey{} + } + if err := m.GovernanceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorList) 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 ErrIntOverflowStake + } + 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: ValidatorList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorKeys", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorKeys = append(m.ValidatorKeys, &v1alpha1.IdentityKey{}) + if err := m.ValidatorKeys[len(m.ValidatorKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FundingStream) 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 ErrIntOverflowStake + } + 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: FundingStream: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FundingStream: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &FundingStream_ToAddress{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Recipient = &FundingStream_ToAddress_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ToCommunityPool", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &FundingStream_ToCommunityPool{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Recipient = &FundingStream_ToCommunityPool_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FundingStream_ToAddress) 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 ErrIntOverflowStake + } + 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: ToAddress: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ToAddress: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + 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 ErrInvalidLengthStake + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType) + } + m.RateBps = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RateBps |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FundingStream_ToCommunityPool) 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 ErrIntOverflowStake + } + 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: ToCommunityPool: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ToCommunityPool: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType) + } + m.RateBps = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RateBps |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } - return n -} -func sovStake(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozStake(x uint64) (n int) { - return sovStake(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil } -func (m *Validator) Unmarshal(dAtA []byte) error { +func (m *RateData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3187,10 +5439,10 @@ func (m *Validator) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Validator: wiretype end group for non-group") + return fmt.Errorf("proto: RateData: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RateData: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3230,10 +5482,10 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKey", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType) } - var byteLen int + m.EpochIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3243,31 +5495,211 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.EpochIndex |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthStake + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorRewardRate", wireType) } - postIndex := iNdEx + byteLen - if postIndex < 0 { + m.ValidatorRewardRate = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValidatorRewardRate |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorExchangeRate", wireType) + } + m.ValidatorExchangeRate = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValidatorExchangeRate |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthStake } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.ConsensusKey = append(m.ConsensusKey[:0], dAtA[iNdEx:postIndex]...) - if m.ConsensusKey == nil { - m.ConsensusKey = []byte{} + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BaseRateData) 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 ErrIntOverflowStake + } + 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: BaseRateData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BaseRateData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType) + } + m.EpochIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EpochIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType) + } + m.BaseRewardRate = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BaseRewardRate |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseExchangeRate", wireType) + } + m.BaseExchangeRate = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BaseExchangeRate |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorStatus) 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 ErrIntOverflowStake + } + 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: ValidatorStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3277,29 +5709,33 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + if m.IdentityKey == nil { + m.IdentityKey = &v1alpha1.IdentityKey{} + } + if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 4: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Website", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3309,29 +5745,33 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - m.Website = string(dAtA[iNdEx:postIndex]) + if m.State == nil { + m.State = &ValidatorState{} + } + if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType) } - var stringLen uint64 + m.VotingPower = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3341,27 +5781,14 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.VotingPower |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthStake - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthStake - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Description = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 6: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FundingStreams", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BondingState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3388,16 +5815,68 @@ func (m *Validator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.FundingStreams = append(m.FundingStreams, &FundingStream{}) - if err := m.FundingStreams[len(m.FundingStreams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.BondingState == nil { + m.BondingState = &BondingState{} + } + if err := m.BondingState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 7: + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BondingState) 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 ErrIntOverflowStake + } + 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: BondingState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BondingState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } - m.SequenceNumber = 0 + m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3407,16 +5886,16 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SequenceNumber |= uint32(b&0x7F) << shift + m.State |= BondingState_BondingStateEnum(b&0x7F) << shift if b < 0x80 { break } } - case 8: + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingEpoch", wireType) } - var v int + m.UnbondingEpoch = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3426,17 +5905,66 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.UnbondingEpoch |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.Enabled = bool(v != 0) - case 9: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GovernanceKey", wireType) + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err } - var msglen int + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorState) 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 ErrIntOverflowStake + } + 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: ValidatorState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3446,28 +5974,11 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.State |= ValidatorState_ValidatorStateEnum(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthStake - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthStake - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.GovernanceKey == nil { - m.GovernanceKey = &v1alpha1.GovernanceKey{} - } - if err := m.GovernanceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStake(dAtA[iNdEx:]) @@ -3489,7 +6000,7 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } return nil } -func (m *ValidatorList) Unmarshal(dAtA []byte) error { +func (m *ValidatorInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3499,28 +6010,100 @@ func (m *ValidatorList) Unmarshal(dAtA []byte) error { if shift >= 64 { return ErrIntOverflowStake } - if iNdEx >= l { + 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: ValidatorInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Validator == nil { + m.Validator = &Validator{} + } + if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.Status == nil { + m.Status = &ValidatorStatus{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ValidatorList: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ValidatorList: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorKeys", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3547,8 +6130,10 @@ func (m *ValidatorList) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ValidatorKeys = append(m.ValidatorKeys, &v1alpha1.IdentityKey{}) - if err := m.ValidatorKeys[len(m.ValidatorKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.RateData == nil { + m.RateData = &RateData{} + } + if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -3573,7 +6158,7 @@ func (m *ValidatorList) Unmarshal(dAtA []byte) error { } return nil } -func (m *FundingStream) Unmarshal(dAtA []byte) error { +func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3596,15 +6181,15 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: FundingStream: wiretype end group for non-group") + return fmt.Errorf("proto: ValidatorDefinition: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: FundingStream: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ValidatorDefinition: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3631,17 +6216,18 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &FundingStream_ToAddress{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Validator == nil { + m.Validator = &Validator{} + } + if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Recipient = &FundingStream_ToAddress_{v} iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ToDao", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3651,26 +6237,25 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - v := &FundingStream_ToDao{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.AuthSig = append(m.AuthSig[:0], dAtA[iNdEx:postIndex]...) + if m.AuthSig == nil { + m.AuthSig = []byte{} } - m.Recipient = &FundingStream_ToDao_{v} iNdEx = postIndex default: iNdEx = preIndex @@ -3693,7 +6278,7 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error { } return nil } -func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error { +func (m *Delegate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3716,17 +6301,17 @@ func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ToAddress: wiretype end group for non-group") + return fmt.Errorf("proto: Delegate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ToAddress: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Delegate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3736,29 +6321,33 @@ func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - m.Address = string(dAtA[iNdEx:postIndex]) + if m.ValidatorIdentity == nil { + m.ValidatorIdentity = &v1alpha1.IdentityKey{} + } + if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType) } - m.RateBps = 0 + m.EpochIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3768,66 +6357,52 @@ func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RateBps |= uint32(b&0x7F) << shift + m.EpochIndex |= uint64(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipStake(dAtA[iNdEx:]) - if err != nil { - return err + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthStake + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthStake } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *FundingStream_ToDao) 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 ErrIntOverflowStake + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.UnbondedAmount == nil { + m.UnbondedAmount = &v1alpha11.Amount{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ToDao: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ToDao: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType) + if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.RateBps = 0 + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3837,11 +6412,28 @@ func (m *FundingStream_ToDao) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RateBps |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DelegationAmount == nil { + m.DelegationAmount = &v1alpha11.Amount{} + } + if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStake(dAtA[iNdEx:]) @@ -3863,7 +6455,7 @@ func (m *FundingStream_ToDao) Unmarshal(dAtA []byte) error { } return nil } -func (m *RateData) Unmarshal(dAtA []byte) error { +func (m *Undelegate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3886,15 +6478,15 @@ func (m *RateData) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RateData: wiretype end group for non-group") + return fmt.Errorf("proto: Undelegate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RateData: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Undelegate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3921,18 +6513,18 @@ func (m *RateData) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.IdentityKey == nil { - m.IdentityKey = &v1alpha1.IdentityKey{} + if m.ValidatorIdentity == nil { + m.ValidatorIdentity = &v1alpha1.IdentityKey{} } - if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType) } - m.EpochIndex = 0 + m.StartEpochIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3942,16 +6534,52 @@ func (m *RateData) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EpochIndex |= uint64(b&0x7F) << shift + m.StartEpochIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.UnbondedAmount == nil { + m.UnbondedAmount = &v1alpha11.Amount{} + } + if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorRewardRate", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType) } - m.ValidatorRewardRate = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -3961,30 +6589,28 @@ func (m *RateData) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ValidatorRewardRate |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorExchangeRate", wireType) + if msglen < 0 { + return ErrInvalidLengthStake } - m.ValidatorExchangeRate = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStake - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ValidatorExchangeRate |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DelegationAmount == nil { + m.DelegationAmount = &v1alpha11.Amount{} } + if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStake(dAtA[iNdEx:]) @@ -4006,7 +6632,7 @@ func (m *RateData) Unmarshal(dAtA []byte) error { } return nil } -func (m *BaseRateData) Unmarshal(dAtA []byte) error { +func (m *UndelegateClaim) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4029,17 +6655,17 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BaseRateData: wiretype end group for non-group") + return fmt.Errorf("proto: UndelegateClaim: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BaseRateData: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UndelegateClaim: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) } - m.EpochIndex = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4049,16 +6675,33 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EpochIndex |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = &UndelegateClaimBody{} + } + if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) } - m.BaseRewardRate = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4068,30 +6711,26 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.BaseRewardRate |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BaseExchangeRate", wireType) + if byteLen < 0 { + return ErrInvalidLengthStake } - m.BaseExchangeRate = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStake - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.BaseExchangeRate |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...) + if m.Proof == nil { + m.Proof = []byte{} } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStake(dAtA[iNdEx:]) @@ -4113,7 +6752,7 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error { } return nil } -func (m *ValidatorStatus) Unmarshal(dAtA []byte) error { +func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4136,15 +6775,15 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ValidatorStatus: wiretype end group for non-group") + return fmt.Errorf("proto: UndelegateClaimBody: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ValidatorStatus: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UndelegateClaimBody: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4171,54 +6810,18 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.IdentityKey == nil { - m.IdentityKey = &v1alpha1.IdentityKey{} + if m.ValidatorIdentity == nil { + m.ValidatorIdentity = &v1alpha1.IdentityKey{} } - if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStake - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthStake - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthStake - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.State == nil { - m.State = &ValidatorState{} - } - if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType) } - m.VotingPower = 0 + m.StartEpochIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4228,14 +6831,14 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.VotingPower |= uint64(b&0x7F) << shift + m.StartEpochIndex |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 4: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BondingState", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4262,68 +6865,18 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.BondingState == nil { - m.BondingState = &BondingState{} + if m.Penalty == nil { + m.Penalty = &Penalty{} } - if err := m.BondingState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipStake(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthStake - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *BondingState) 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 ErrIntOverflowStake - } - 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: BondingState: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: BondingState: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType) } - m.State = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4333,31 +6886,28 @@ func (m *BondingState) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.State |= BondingState_BondingStateEnum(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field UnbondingEpoch", wireType) + if msglen < 0 { + return ErrInvalidLengthStake } - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStake - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BalanceCommitment == nil { + m.BalanceCommitment = &v1alpha12.BalanceCommitment{} } - m.XUnbondingEpoch = &BondingState_UnbondingEpoch{v} + if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStake(dAtA[iNdEx:]) @@ -4379,7 +6929,7 @@ func (m *BondingState) Unmarshal(dAtA []byte) error { } return nil } -func (m *ValidatorState) Unmarshal(dAtA []byte) error { +func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4402,17 +6952,17 @@ func (m *ValidatorState) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ValidatorState: wiretype end group for non-group") + return fmt.Errorf("proto: UndelegateClaimPlan: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ValidatorState: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UndelegateClaimPlan: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType) } - m.State = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4422,64 +6972,50 @@ func (m *ValidatorState) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.State |= ValidatorState_ValidatorStateEnum(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipStake(dAtA[iNdEx:]) - if err != nil { - return err + if msglen < 0 { + return ErrInvalidLengthStake } - if (skippy < 0) || (iNdEx+skippy) < 0 { + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthStake } - if (iNdEx + skippy) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ValidatorInfo) 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 ErrIntOverflowStake + if m.ValidatorIdentity == nil { + m.ValidatorIdentity = &v1alpha1.IdentityKey{} } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ValidatorInfo: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ValidatorInfo: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.StartEpochIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartEpochIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4506,16 +7042,16 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Validator == nil { - m.Validator = &Validator{} + if m.Penalty == nil { + m.Penalty = &Penalty{} } - if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingAmount", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4542,18 +7078,18 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Status == nil { - m.Status = &ValidatorStatus{} + if m.UnbondingAmount == nil { + m.UnbondingAmount = &v1alpha11.Amount{} } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.UnbondingAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BalanceBlinding", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4563,26 +7099,92 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - if m.RateData == nil { - m.RateData = &RateData{} + m.BalanceBlinding = append(m.BalanceBlinding[:0], dAtA[iNdEx:postIndex]...) + if m.BalanceBlinding == nil { + m.BalanceBlinding = []byte{} } - if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingR == nil { + m.ProofBlindingR = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) + if m.ProofBlindingS == nil { + m.ProofBlindingS = []byte{} } iNdEx = postIndex default: @@ -4606,7 +7208,7 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error { +func (m *DelegationChanges) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4629,15 +7231,15 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ValidatorDefinition: wiretype end group for non-group") + return fmt.Errorf("proto: DelegationChanges: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ValidatorDefinition: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DelegationChanges: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4664,18 +7266,16 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Validator == nil { - m.Validator = &Validator{} - } - if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Delegations = append(m.Delegations, &Delegate{}) + if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Undelegations", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4685,24 +7285,24 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - m.AuthSig = append(m.AuthSig[:0], dAtA[iNdEx:postIndex]...) - if m.AuthSig == nil { - m.AuthSig = []byte{} + m.Undelegations = append(m.Undelegations, &Undelegate{}) + if err := m.Undelegations[len(m.Undelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -4726,7 +7326,7 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error { } return nil } -func (m *Delegate) Unmarshal(dAtA []byte) error { +func (m *Uptime) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4749,17 +7349,17 @@ func (m *Delegate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Delegate: wiretype end group for non-group") + return fmt.Errorf("proto: Uptime: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Delegate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Uptime: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AsOfBlockHeight", wireType) } - var msglen int + m.AsOfBlockHeight = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4768,34 +7368,17 @@ func (m *Delegate) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthStake - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthStake - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ValidatorIdentity == nil { - m.ValidatorIdentity = &v1alpha1.IdentityKey{} - } - if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + iNdEx++ + m.AsOfBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WindowLen", wireType) } - m.EpochIndex = 0 + m.WindowLen = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4805,16 +7388,16 @@ func (m *Delegate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EpochIndex |= uint64(b&0x7F) << shift + m.WindowLen |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Bitvec", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4824,31 +7407,79 @@ func (m *Delegate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - if m.UnbondedAmount == nil { - m.UnbondedAmount = &v1alpha1.Amount{} + m.Bitvec = append(m.Bitvec[:0], dAtA[iNdEx:postIndex]...) + if m.Bitvec == nil { + m.Bitvec = []byte{} } - if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { return err } - iNdEx = postIndex - case 4: + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CurrentConsensusKeys) 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 ErrIntOverflowStake + } + 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: CurrentConsensusKeys: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CurrentConsensusKeys: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKeys", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4875,10 +7506,8 @@ func (m *Delegate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DelegationAmount == nil { - m.DelegationAmount = &v1alpha1.Amount{} - } - if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ConsensusKeys = append(m.ConsensusKeys, &v1alpha1.ConsensusKey{}) + if err := m.ConsensusKeys[len(m.ConsensusKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -4903,7 +7532,7 @@ func (m *Delegate) Unmarshal(dAtA []byte) error { } return nil } -func (m *Undelegate) Unmarshal(dAtA []byte) error { +func (m *Penalty) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4926,17 +7555,17 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Undelegate: wiretype end group for non-group") + return fmt.Errorf("proto: Penalty: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Undelegate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Penalty: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -4946,52 +7575,81 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - if m.ValidatorIdentity == nil { - m.ValidatorIdentity = &v1alpha1.IdentityKey{} + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} } - if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { return err } - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType) + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake } - m.StartEpochIndex = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStake - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StartEpochIndex |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - case 3: + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorInfoRequest) 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 ErrIntOverflowStake + } + 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: ValidatorInfoRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -5001,33 +7659,29 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - if m.UnbondedAmount == nil { - m.UnbondedAmount = &v1alpha1.Amount{} - } - if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.ChainId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ShowInactive", wireType) } - var msglen int + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -5037,28 +7691,12 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthStake - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthStake - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.DelegationAmount == nil { - m.DelegationAmount = &v1alpha1.Amount{} - } - if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex + m.ShowInactive = bool(v != 0) default: iNdEx = preIndex skippy, err := skipStake(dAtA[iNdEx:]) @@ -5080,7 +7718,7 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error { } return nil } -func (m *UndelegateClaim) Unmarshal(dAtA []byte) error { +func (m *ValidatorInfoResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5103,15 +7741,15 @@ func (m *UndelegateClaim) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UndelegateClaim: wiretype end group for non-group") + return fmt.Errorf("proto: ValidatorInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UndelegateClaim: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ValidatorInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5138,47 +7776,13 @@ func (m *UndelegateClaim) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Body == nil { - m.Body = &UndelegateClaimBody{} + if m.ValidatorInfo == nil { + m.ValidatorInfo = &ValidatorInfo{} } - if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStake - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthStake - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthStake - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...) - if m.Proof == nil { - m.Proof = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStake(dAtA[iNdEx:]) @@ -5200,7 +7804,7 @@ func (m *UndelegateClaim) Unmarshal(dAtA []byte) error { } return nil } -func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error { +func (m *ValidatorStatusRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5223,17 +7827,17 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UndelegateClaimBody: wiretype end group for non-group") + return fmt.Errorf("proto: ValidatorStatusRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UndelegateClaimBody: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ValidatorStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -5243,50 +7847,27 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - if m.ValidatorIdentity == nil { - m.ValidatorIdentity = &v1alpha1.IdentityKey{} - } - if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.ChainId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType) - } - m.StartEpochIndex = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStake - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StartEpochIndex |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5313,16 +7894,66 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Penalty == nil { - m.Penalty = &Penalty{} + if m.IdentityKey == nil { + m.IdentityKey = &v1alpha1.IdentityKey{} } - if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStake + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorStatusResponse) 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 ErrIntOverflowStake + } + 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: ValidatorStatusResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5349,10 +7980,10 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.BalanceCommitment == nil { - m.BalanceCommitment = &v1alpha1.BalanceCommitment{} + if m.Status == nil { + m.Status = &ValidatorStatus{} } - if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5377,7 +8008,7 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error { } return nil } -func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { +func (m *ValidatorPenaltyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5400,15 +8031,47 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UndelegateClaimPlan: wiretype end group for non-group") + return fmt.Errorf("proto: ValidatorPenaltyRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UndelegateClaimPlan: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ValidatorPenaltyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + 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 ErrInvalidLengthStake + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5435,14 +8098,14 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ValidatorIdentity == nil { - m.ValidatorIdentity = &v1alpha1.IdentityKey{} + if m.IdentityKey == nil { + m.IdentityKey = &v1alpha1.IdentityKey{} } - if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType) } @@ -5462,10 +8125,10 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { } } case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndEpochIndex", wireType) } - var msglen int + m.EndEpochIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -5475,31 +8138,64 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.EndEpochIndex |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthStake + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthStake } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if m.Penalty == nil { - m.Penalty = &Penalty{} + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorPenaltyResponse) 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 ErrIntOverflowStake } - if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + if iNdEx >= l { + return io.ErrUnexpectedEOF } - iNdEx = postIndex - case 5: + 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: ValidatorPenaltyResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorPenaltyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UnbondingAmount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5526,52 +8222,68 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.UnbondingAmount == nil { - m.UnbondingAmount = &v1alpha1.Amount{} + if m.Penalty == nil { + m.Penalty = &Penalty{} } - if err := m.UnbondingAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BalanceBlinding", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStake - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthStake + default: + iNdEx = preIndex + skippy, err := skipStake(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + byteLen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthStake } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.BalanceBlinding = append(m.BalanceBlinding[:0], dAtA[iNdEx:postIndex]...) - if m.BalanceBlinding == nil { - m.BalanceBlinding = []byte{} + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CurrentValidatorRateRequest) 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 ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF } - iNdEx = postIndex - case 7: + 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: CurrentValidatorRateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CurrentValidatorRateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -5581,31 +8293,29 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingR == nil { - m.ProofBlindingR = []byte{} - } + m.ChainId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 8: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -5615,24 +8325,26 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthStake } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthStake } if postIndex > l { return io.ErrUnexpectedEOF } - m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingS == nil { - m.ProofBlindingS = []byte{} + if m.IdentityKey == nil { + m.IdentityKey = &v1alpha1.IdentityKey{} + } + if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -5656,7 +8368,7 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error { } return nil } -func (m *DelegationChanges) Unmarshal(dAtA []byte) error { +func (m *CurrentValidatorRateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5679,15 +8391,15 @@ func (m *DelegationChanges) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DelegationChanges: wiretype end group for non-group") + return fmt.Errorf("proto: CurrentValidatorRateResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DelegationChanges: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CurrentValidatorRateResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5714,42 +8426,10 @@ func (m *DelegationChanges) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Delegations = append(m.Delegations, &Delegate{}) - if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Undelegations", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowStake - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthStake - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthStake - } - if postIndex > l { - return io.ErrUnexpectedEOF + if m.Data == nil { + m.Data = &RateData{} } - m.Undelegations = append(m.Undelegations, &Undelegate{}) - if err := m.Undelegations[len(m.Undelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5774,7 +8454,7 @@ func (m *DelegationChanges) Unmarshal(dAtA []byte) error { } return nil } -func (m *Uptime) Unmarshal(dAtA []byte) error { +func (m *StakeParameters) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5797,17 +8477,17 @@ func (m *Uptime) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Uptime: wiretype end group for non-group") + return fmt.Errorf("proto: StakeParameters: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Uptime: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StakeParameters: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AsOfBlockHeight", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingEpochs", wireType) } - m.AsOfBlockHeight = 0 + m.UnbondingEpochs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -5817,16 +8497,16 @@ func (m *Uptime) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.AsOfBlockHeight |= uint64(b&0x7F) << shift + m.UnbondingEpochs |= uint64(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field WindowLen", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ActiveValidatorLimit", wireType) } - m.WindowLen = 0 + m.ActiveValidatorLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -5836,16 +8516,16 @@ func (m *Uptime) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.WindowLen |= uint32(b&0x7F) << shift + m.ActiveValidatorLimit |= uint64(b&0x7F) << shift if b < 0x80 { break } } case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bitvec", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType) } - var byteLen int + m.BaseRewardRate = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -5855,26 +8535,87 @@ func (m *Uptime) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.BaseRewardRate |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthStake + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyMisbehavior", wireType) } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthStake + m.SlashingPenaltyMisbehavior = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SlashingPenaltyMisbehavior |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if postIndex > l { - return io.ErrUnexpectedEOF + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyDowntime", wireType) } - m.Bitvec = append(m.Bitvec[:0], dAtA[iNdEx:postIndex]...) - if m.Bitvec == nil { - m.Bitvec = []byte{} + m.SlashingPenaltyDowntime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SlashingPenaltyDowntime |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SignedBlocksWindowLen", wireType) + } + m.SignedBlocksWindowLen = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SignedBlocksWindowLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MissedBlocksMaximum", wireType) + } + m.MissedBlocksMaximum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStake + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MissedBlocksMaximum |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStake(dAtA[iNdEx:]) @@ -5896,7 +8637,7 @@ func (m *Uptime) Unmarshal(dAtA []byte) error { } return nil } -func (m *CurrentConsensusKeys) Unmarshal(dAtA []byte) error { +func (m *GenesisContent) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5919,15 +8660,15 @@ func (m *CurrentConsensusKeys) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CurrentConsensusKeys: wiretype end group for non-group") + return fmt.Errorf("proto: GenesisContent: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CurrentConsensusKeys: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKeys", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StakeParams", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5954,66 +8695,18 @@ func (m *CurrentConsensusKeys) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ConsensusKeys = append(m.ConsensusKeys, &v1alpha1.ConsensusKey{}) - if err := m.ConsensusKeys[len(m.ConsensusKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + if m.StakeParams == nil { + m.StakeParams = &StakeParameters{} } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipStake(dAtA[iNdEx:]) - if err != nil { + if err := m.StakeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthStake - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Penalty) 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 ErrIntOverflowStake - } - 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: Penalty: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Penalty: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) } - m.Inner = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowStake @@ -6023,11 +8716,26 @@ func (m *Penalty) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Inner |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthStake + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStake + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Validators = append(m.Validators, &Validator{}) + if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipStake(dAtA[iNdEx:]) diff --git a/relayer/chains/penumbra/core/crypto/v1alpha1/crypto.pb.go b/relayer/chains/penumbra/core/crypto/v1alpha1/crypto.pb.go deleted file mode 100644 index 088785c8e..000000000 --- a/relayer/chains/penumbra/core/crypto/v1alpha1/crypto.pb.go +++ /dev/null @@ -1,9861 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: penumbra/core/crypto/v1alpha1/crypto.proto - -package cryptov1alpha1 - -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 - -// Specifies fees paid by a transaction. -type Fee struct { - // The amount of the token used to pay fees. - Amount *Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` - // If present, the asset ID of the token used to pay fees. - // If absent, specifies the staking token implicitly. - AssetId *AssetId `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` -} - -func (m *Fee) Reset() { *m = Fee{} } -func (m *Fee) String() string { return proto.CompactTextString(m) } -func (*Fee) ProtoMessage() {} -func (*Fee) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{0} -} -func (m *Fee) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Fee) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Fee.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 *Fee) XXX_Merge(src proto.Message) { - xxx_messageInfo_Fee.Merge(m, src) -} -func (m *Fee) XXX_Size() int { - return m.Size() -} -func (m *Fee) XXX_DiscardUnknown() { - xxx_messageInfo_Fee.DiscardUnknown(m) -} - -var xxx_messageInfo_Fee proto.InternalMessageInfo - -func (m *Fee) GetAmount() *Amount { - if m != nil { - return m.Amount - } - return nil -} - -func (m *Fee) GetAssetId() *AssetId { - if m != nil { - return m.AssetId - } - return nil -} - -// A Penumbra address. An address in Penumbra is a Bech32m-encoded -// string, with the human-readable prefix (HRP) `penumbrav2t`. -type Address struct { - // The bytes of the address. Must be represented as a series of - // `uint8` (i.e. values 0 through 255), with a length of 80 elements. - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` - // Alternatively, a Bech32m-encoded string representation of the `inner` - // bytes. - // - // NOTE: implementations are not required to support parsing this field. - // Implementations should prefer to encode the bytes in all messages they - // produce. Implementations must not accept messages with both `inner` and - // `alt_bech32m` set. - AltBech32M string `protobuf:"bytes,2,opt,name=alt_bech32m,json=altBech32m,proto3" json:"alt_bech32m,omitempty"` -} - -func (m *Address) Reset() { *m = Address{} } -func (m *Address) String() string { return proto.CompactTextString(m) } -func (*Address) ProtoMessage() {} -func (*Address) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{1} -} -func (m *Address) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Address) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Address.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 *Address) XXX_Merge(src proto.Message) { - xxx_messageInfo_Address.Merge(m, src) -} -func (m *Address) XXX_Size() int { - return m.Size() -} -func (m *Address) XXX_DiscardUnknown() { - xxx_messageInfo_Address.DiscardUnknown(m) -} - -var xxx_messageInfo_Address proto.InternalMessageInfo - -func (m *Address) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -func (m *Address) GetAltBech32M() string { - if m != nil { - return m.AltBech32M - } - return "" -} - -type AddressView struct { - // Types that are valid to be assigned to AddressView: - // - // *AddressView_Visible_ - // *AddressView_Opaque_ - AddressView isAddressView_AddressView `protobuf_oneof:"address_view"` -} - -func (m *AddressView) Reset() { *m = AddressView{} } -func (m *AddressView) String() string { return proto.CompactTextString(m) } -func (*AddressView) ProtoMessage() {} -func (*AddressView) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{2} -} -func (m *AddressView) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AddressView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AddressView.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 *AddressView) XXX_Merge(src proto.Message) { - xxx_messageInfo_AddressView.Merge(m, src) -} -func (m *AddressView) XXX_Size() int { - return m.Size() -} -func (m *AddressView) XXX_DiscardUnknown() { - xxx_messageInfo_AddressView.DiscardUnknown(m) -} - -var xxx_messageInfo_AddressView proto.InternalMessageInfo - -type isAddressView_AddressView interface { - isAddressView_AddressView() - MarshalTo([]byte) (int, error) - Size() int -} - -type AddressView_Visible_ struct { - Visible *AddressView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` -} -type AddressView_Opaque_ struct { - Opaque *AddressView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` -} - -func (*AddressView_Visible_) isAddressView_AddressView() {} -func (*AddressView_Opaque_) isAddressView_AddressView() {} - -func (m *AddressView) GetAddressView() isAddressView_AddressView { - if m != nil { - return m.AddressView - } - return nil -} - -func (m *AddressView) GetVisible() *AddressView_Visible { - if x, ok := m.GetAddressView().(*AddressView_Visible_); ok { - return x.Visible - } - return nil -} - -func (m *AddressView) GetOpaque() *AddressView_Opaque { - if x, ok := m.GetAddressView().(*AddressView_Opaque_); ok { - return x.Opaque - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*AddressView) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*AddressView_Visible_)(nil), - (*AddressView_Opaque_)(nil), - } -} - -type AddressView_Visible struct { - Address *Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - Index *AddressIndex `protobuf:"bytes,2,opt,name=index,proto3" json:"index,omitempty"` - AccountGroupId *AccountGroupId `protobuf:"bytes,3,opt,name=account_group_id,json=accountGroupId,proto3" json:"account_group_id,omitempty"` -} - -func (m *AddressView_Visible) Reset() { *m = AddressView_Visible{} } -func (m *AddressView_Visible) String() string { return proto.CompactTextString(m) } -func (*AddressView_Visible) ProtoMessage() {} -func (*AddressView_Visible) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{2, 0} -} -func (m *AddressView_Visible) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AddressView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AddressView_Visible.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 *AddressView_Visible) XXX_Merge(src proto.Message) { - xxx_messageInfo_AddressView_Visible.Merge(m, src) -} -func (m *AddressView_Visible) XXX_Size() int { - return m.Size() -} -func (m *AddressView_Visible) XXX_DiscardUnknown() { - xxx_messageInfo_AddressView_Visible.DiscardUnknown(m) -} - -var xxx_messageInfo_AddressView_Visible proto.InternalMessageInfo - -func (m *AddressView_Visible) GetAddress() *Address { - if m != nil { - return m.Address - } - return nil -} - -func (m *AddressView_Visible) GetIndex() *AddressIndex { - if m != nil { - return m.Index - } - return nil -} - -func (m *AddressView_Visible) GetAccountGroupId() *AccountGroupId { - if m != nil { - return m.AccountGroupId - } - return nil -} - -type AddressView_Opaque struct { - Address *Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` -} - -func (m *AddressView_Opaque) Reset() { *m = AddressView_Opaque{} } -func (m *AddressView_Opaque) String() string { return proto.CompactTextString(m) } -func (*AddressView_Opaque) ProtoMessage() {} -func (*AddressView_Opaque) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{2, 1} -} -func (m *AddressView_Opaque) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AddressView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AddressView_Opaque.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 *AddressView_Opaque) XXX_Merge(src proto.Message) { - xxx_messageInfo_AddressView_Opaque.Merge(m, src) -} -func (m *AddressView_Opaque) XXX_Size() int { - return m.Size() -} -func (m *AddressView_Opaque) XXX_DiscardUnknown() { - xxx_messageInfo_AddressView_Opaque.DiscardUnknown(m) -} - -var xxx_messageInfo_AddressView_Opaque proto.InternalMessageInfo - -func (m *AddressView_Opaque) GetAddress() *Address { - if m != nil { - return m.Address - } - return nil -} - -type SpendKey struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *SpendKey) Reset() { *m = SpendKey{} } -func (m *SpendKey) String() string { return proto.CompactTextString(m) } -func (*SpendKey) ProtoMessage() {} -func (*SpendKey) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{3} -} -func (m *SpendKey) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SpendKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SpendKey.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 *SpendKey) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpendKey.Merge(m, src) -} -func (m *SpendKey) XXX_Size() int { - return m.Size() -} -func (m *SpendKey) XXX_DiscardUnknown() { - xxx_messageInfo_SpendKey.DiscardUnknown(m) -} - -var xxx_messageInfo_SpendKey proto.InternalMessageInfo - -func (m *SpendKey) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type SpendVerificationKey struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *SpendVerificationKey) Reset() { *m = SpendVerificationKey{} } -func (m *SpendVerificationKey) String() string { return proto.CompactTextString(m) } -func (*SpendVerificationKey) ProtoMessage() {} -func (*SpendVerificationKey) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{4} -} -func (m *SpendVerificationKey) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SpendVerificationKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SpendVerificationKey.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 *SpendVerificationKey) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpendVerificationKey.Merge(m, src) -} -func (m *SpendVerificationKey) XXX_Size() int { - return m.Size() -} -func (m *SpendVerificationKey) XXX_DiscardUnknown() { - xxx_messageInfo_SpendVerificationKey.DiscardUnknown(m) -} - -var xxx_messageInfo_SpendVerificationKey proto.InternalMessageInfo - -func (m *SpendVerificationKey) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type FullViewingKey struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *FullViewingKey) Reset() { *m = FullViewingKey{} } -func (m *FullViewingKey) String() string { return proto.CompactTextString(m) } -func (*FullViewingKey) ProtoMessage() {} -func (*FullViewingKey) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{5} -} -func (m *FullViewingKey) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *FullViewingKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_FullViewingKey.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 *FullViewingKey) XXX_Merge(src proto.Message) { - xxx_messageInfo_FullViewingKey.Merge(m, src) -} -func (m *FullViewingKey) XXX_Size() int { - return m.Size() -} -func (m *FullViewingKey) XXX_DiscardUnknown() { - xxx_messageInfo_FullViewingKey.DiscardUnknown(m) -} - -var xxx_messageInfo_FullViewingKey proto.InternalMessageInfo - -func (m *FullViewingKey) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type AccountGroupId struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *AccountGroupId) Reset() { *m = AccountGroupId{} } -func (m *AccountGroupId) String() string { return proto.CompactTextString(m) } -func (*AccountGroupId) ProtoMessage() {} -func (*AccountGroupId) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{6} -} -func (m *AccountGroupId) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AccountGroupId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AccountGroupId.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 *AccountGroupId) XXX_Merge(src proto.Message) { - xxx_messageInfo_AccountGroupId.Merge(m, src) -} -func (m *AccountGroupId) XXX_Size() int { - return m.Size() -} -func (m *AccountGroupId) XXX_DiscardUnknown() { - xxx_messageInfo_AccountGroupId.DiscardUnknown(m) -} - -var xxx_messageInfo_AccountGroupId proto.InternalMessageInfo - -func (m *AccountGroupId) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type Diversifier struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *Diversifier) Reset() { *m = Diversifier{} } -func (m *Diversifier) String() string { return proto.CompactTextString(m) } -func (*Diversifier) ProtoMessage() {} -func (*Diversifier) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{7} -} -func (m *Diversifier) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Diversifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Diversifier.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 *Diversifier) XXX_Merge(src proto.Message) { - xxx_messageInfo_Diversifier.Merge(m, src) -} -func (m *Diversifier) XXX_Size() int { - return m.Size() -} -func (m *Diversifier) XXX_DiscardUnknown() { - xxx_messageInfo_Diversifier.DiscardUnknown(m) -} - -var xxx_messageInfo_Diversifier proto.InternalMessageInfo - -func (m *Diversifier) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type AddressIndex struct { - Account uint32 `protobuf:"varint,2,opt,name=account,proto3" json:"account,omitempty"` - Randomizer []byte `protobuf:"bytes,3,opt,name=randomizer,proto3" json:"randomizer,omitempty"` -} - -func (m *AddressIndex) Reset() { *m = AddressIndex{} } -func (m *AddressIndex) String() string { return proto.CompactTextString(m) } -func (*AddressIndex) ProtoMessage() {} -func (*AddressIndex) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{8} -} -func (m *AddressIndex) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AddressIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AddressIndex.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 *AddressIndex) XXX_Merge(src proto.Message) { - xxx_messageInfo_AddressIndex.Merge(m, src) -} -func (m *AddressIndex) XXX_Size() int { - return m.Size() -} -func (m *AddressIndex) XXX_DiscardUnknown() { - xxx_messageInfo_AddressIndex.DiscardUnknown(m) -} - -var xxx_messageInfo_AddressIndex proto.InternalMessageInfo - -func (m *AddressIndex) GetAccount() uint32 { - if m != nil { - return m.Account - } - return 0 -} - -func (m *AddressIndex) GetRandomizer() []byte { - if m != nil { - return m.Randomizer - } - return nil -} - -type StateCommitment struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *StateCommitment) Reset() { *m = StateCommitment{} } -func (m *StateCommitment) String() string { return proto.CompactTextString(m) } -func (*StateCommitment) ProtoMessage() {} -func (*StateCommitment) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{9} -} -func (m *StateCommitment) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StateCommitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StateCommitment.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 *StateCommitment) XXX_Merge(src proto.Message) { - xxx_messageInfo_StateCommitment.Merge(m, src) -} -func (m *StateCommitment) XXX_Size() int { - return m.Size() -} -func (m *StateCommitment) XXX_DiscardUnknown() { - xxx_messageInfo_StateCommitment.DiscardUnknown(m) -} - -var xxx_messageInfo_StateCommitment proto.InternalMessageInfo - -func (m *StateCommitment) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type BalanceCommitment struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *BalanceCommitment) Reset() { *m = BalanceCommitment{} } -func (m *BalanceCommitment) String() string { return proto.CompactTextString(m) } -func (*BalanceCommitment) ProtoMessage() {} -func (*BalanceCommitment) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{10} -} -func (m *BalanceCommitment) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *BalanceCommitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_BalanceCommitment.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 *BalanceCommitment) XXX_Merge(src proto.Message) { - xxx_messageInfo_BalanceCommitment.Merge(m, src) -} -func (m *BalanceCommitment) XXX_Size() int { - return m.Size() -} -func (m *BalanceCommitment) XXX_DiscardUnknown() { - xxx_messageInfo_BalanceCommitment.DiscardUnknown(m) -} - -var xxx_messageInfo_BalanceCommitment proto.InternalMessageInfo - -func (m *BalanceCommitment) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A Penumbra asset ID. -type AssetId struct { - // The bytes of the asset ID. - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` - // Alternatively, a Bech32m-encoded string representation of the `inner` - // bytes. - // - // NOTE: implementations are not required to support parsing this field. - // Implementations should prefer to encode the `inner` bytes in all messages they - // produce. Implementations must not accept messages with both `inner` and - // `alt_bech32m` set. This field exists for convenience of RPC users. - AltBech32M string `protobuf:"bytes,2,opt,name=alt_bech32m,json=altBech32m,proto3" json:"alt_bech32m,omitempty"` - // Alternatively, a base denomination string which should be hashed to obtain the asset ID. - // - // NOTE: implementations are not required to support parsing this field. - // Implementations should prefer to encode the bytes in all messages they - // produce. Implementations must not accept messages with both `inner` and - // `alt_base_denom` set. This field exists for convenience of RPC users. - AltBaseDenom string `protobuf:"bytes,3,opt,name=alt_base_denom,json=altBaseDenom,proto3" json:"alt_base_denom,omitempty"` -} - -func (m *AssetId) Reset() { *m = AssetId{} } -func (m *AssetId) String() string { return proto.CompactTextString(m) } -func (*AssetId) ProtoMessage() {} -func (*AssetId) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{11} -} -func (m *AssetId) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AssetId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AssetId.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 *AssetId) XXX_Merge(src proto.Message) { - xxx_messageInfo_AssetId.Merge(m, src) -} -func (m *AssetId) XXX_Size() int { - return m.Size() -} -func (m *AssetId) XXX_DiscardUnknown() { - xxx_messageInfo_AssetId.DiscardUnknown(m) -} - -var xxx_messageInfo_AssetId proto.InternalMessageInfo - -func (m *AssetId) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -func (m *AssetId) GetAltBech32M() string { - if m != nil { - return m.AltBech32M - } - return "" -} - -func (m *AssetId) GetAltBaseDenom() string { - if m != nil { - return m.AltBaseDenom - } - return "" -} - -// The quantity of a particular Asset. Represented as a 128-bit unsigned integer, -// split over two fields, `lo` and `hi`, representing the low- and high-order bytes -// of the 128-bit value, respectively. Clients must assemble these bits in their -// implementation into a `uint128` or comparable data structure, in order to model -// the Amount accurately. -type Amount struct { - Lo uint64 `protobuf:"varint,1,opt,name=lo,proto3" json:"lo,omitempty"` - Hi uint64 `protobuf:"varint,2,opt,name=hi,proto3" json:"hi,omitempty"` -} - -func (m *Amount) Reset() { *m = Amount{} } -func (m *Amount) String() string { return proto.CompactTextString(m) } -func (*Amount) ProtoMessage() {} -func (*Amount) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{12} -} -func (m *Amount) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Amount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Amount.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 *Amount) XXX_Merge(src proto.Message) { - xxx_messageInfo_Amount.Merge(m, src) -} -func (m *Amount) XXX_Size() int { - return m.Size() -} -func (m *Amount) XXX_DiscardUnknown() { - xxx_messageInfo_Amount.DiscardUnknown(m) -} - -var xxx_messageInfo_Amount proto.InternalMessageInfo - -func (m *Amount) GetLo() uint64 { - if m != nil { - return m.Lo - } - return 0 -} - -func (m *Amount) GetHi() uint64 { - if m != nil { - return m.Hi - } - return 0 -} - -type Denom struct { - Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` -} - -func (m *Denom) Reset() { *m = Denom{} } -func (m *Denom) String() string { return proto.CompactTextString(m) } -func (*Denom) ProtoMessage() {} -func (*Denom) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{13} -} -func (m *Denom) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Denom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Denom.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 *Denom) XXX_Merge(src proto.Message) { - xxx_messageInfo_Denom.Merge(m, src) -} -func (m *Denom) XXX_Size() int { - return m.Size() -} -func (m *Denom) XXX_DiscardUnknown() { - xxx_messageInfo_Denom.DiscardUnknown(m) -} - -var xxx_messageInfo_Denom proto.InternalMessageInfo - -func (m *Denom) GetDenom() string { - if m != nil { - return m.Denom - } - return "" -} - -// DenomMetadata represents a struct that describes a basic token. -type DenomMetadata struct { - Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"` - // denom_units represents the list of DenomUnit's for a given coin - DenomUnits []*DenomUnit `protobuf:"bytes,2,rep,name=denom_units,json=denomUnits,proto3" json:"denom_units,omitempty"` - // base represents the base denom (should be the DenomUnit with exponent = 0). - Base string `protobuf:"bytes,3,opt,name=base,proto3" json:"base,omitempty"` - // display indicates the suggested denom that should be - // displayed in clients. - Display string `protobuf:"bytes,4,opt,name=display,proto3" json:"display,omitempty"` - // name defines the name of the token (eg: Cosmos Atom) - Name string `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"` - // symbol is the token symbol usually shown on exchanges (eg: ATOM). This can - // be the same as the display. - Symbol string `protobuf:"bytes,6,opt,name=symbol,proto3" json:"symbol,omitempty"` - // URI to a document (on or off-chain) that contains additional information. Optional. - Uri string `protobuf:"bytes,7,opt,name=uri,proto3" json:"uri,omitempty"` - // URIHash is a sha256 hash of a document pointed by URI. It's used to verify that - // the document didn't change. Optional. - UriHash string `protobuf:"bytes,8,opt,name=uri_hash,json=uriHash,proto3" json:"uri_hash,omitempty"` - // the asset ID on Penumbra for this denomination. - PenumbraAssetId *AssetId `protobuf:"bytes,1984,opt,name=penumbra_asset_id,json=penumbraAssetId,proto3" json:"penumbra_asset_id,omitempty"` -} - -func (m *DenomMetadata) Reset() { *m = DenomMetadata{} } -func (m *DenomMetadata) String() string { return proto.CompactTextString(m) } -func (*DenomMetadata) ProtoMessage() {} -func (*DenomMetadata) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{14} -} -func (m *DenomMetadata) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DenomMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DenomMetadata.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 *DenomMetadata) XXX_Merge(src proto.Message) { - xxx_messageInfo_DenomMetadata.Merge(m, src) -} -func (m *DenomMetadata) XXX_Size() int { - return m.Size() -} -func (m *DenomMetadata) XXX_DiscardUnknown() { - xxx_messageInfo_DenomMetadata.DiscardUnknown(m) -} - -var xxx_messageInfo_DenomMetadata proto.InternalMessageInfo - -func (m *DenomMetadata) GetDescription() string { - if m != nil { - return m.Description - } - return "" -} - -func (m *DenomMetadata) GetDenomUnits() []*DenomUnit { - if m != nil { - return m.DenomUnits - } - return nil -} - -func (m *DenomMetadata) GetBase() string { - if m != nil { - return m.Base - } - return "" -} - -func (m *DenomMetadata) GetDisplay() string { - if m != nil { - return m.Display - } - return "" -} - -func (m *DenomMetadata) GetName() string { - if m != nil { - return m.Name - } - return "" -} - -func (m *DenomMetadata) GetSymbol() string { - if m != nil { - return m.Symbol - } - return "" -} - -func (m *DenomMetadata) GetUri() string { - if m != nil { - return m.Uri - } - return "" -} - -func (m *DenomMetadata) GetUriHash() string { - if m != nil { - return m.UriHash - } - return "" -} - -func (m *DenomMetadata) GetPenumbraAssetId() *AssetId { - if m != nil { - return m.PenumbraAssetId - } - return nil -} - -// DenomUnit represents a struct that describes a given denomination unit of the basic token. -type DenomUnit struct { - // denom represents the string name of the given denom unit (e.g uatom). - Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` - // exponent represents power of 10 exponent that one must - // raise the base_denom to in order to equal the given DenomUnit's denom - // 1 denom = 10^exponent base_denom - // (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with - // exponent = 6, thus: 1 atom = 10^6 uatom). - Exponent uint32 `protobuf:"varint,2,opt,name=exponent,proto3" json:"exponent,omitempty"` - // aliases is a list of string aliases for the given denom - Aliases []string `protobuf:"bytes,3,rep,name=aliases,proto3" json:"aliases,omitempty"` -} - -func (m *DenomUnit) Reset() { *m = DenomUnit{} } -func (m *DenomUnit) String() string { return proto.CompactTextString(m) } -func (*DenomUnit) ProtoMessage() {} -func (*DenomUnit) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{15} -} -func (m *DenomUnit) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DenomUnit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DenomUnit.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 *DenomUnit) XXX_Merge(src proto.Message) { - xxx_messageInfo_DenomUnit.Merge(m, src) -} -func (m *DenomUnit) XXX_Size() int { - return m.Size() -} -func (m *DenomUnit) XXX_DiscardUnknown() { - xxx_messageInfo_DenomUnit.DiscardUnknown(m) -} - -var xxx_messageInfo_DenomUnit proto.InternalMessageInfo - -func (m *DenomUnit) GetDenom() string { - if m != nil { - return m.Denom - } - return "" -} - -func (m *DenomUnit) GetExponent() uint32 { - if m != nil { - return m.Exponent - } - return 0 -} - -func (m *DenomUnit) GetAliases() []string { - if m != nil { - return m.Aliases - } - return nil -} - -type Value struct { - Amount *Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` - AssetId *AssetId `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` -} - -func (m *Value) Reset() { *m = Value{} } -func (m *Value) String() string { return proto.CompactTextString(m) } -func (*Value) ProtoMessage() {} -func (*Value) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{16} -} -func (m *Value) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Value.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 *Value) XXX_Merge(src proto.Message) { - xxx_messageInfo_Value.Merge(m, src) -} -func (m *Value) XXX_Size() int { - return m.Size() -} -func (m *Value) XXX_DiscardUnknown() { - xxx_messageInfo_Value.DiscardUnknown(m) -} - -var xxx_messageInfo_Value proto.InternalMessageInfo - -func (m *Value) GetAmount() *Amount { - if m != nil { - return m.Amount - } - return nil -} - -func (m *Value) GetAssetId() *AssetId { - if m != nil { - return m.AssetId - } - return nil -} - -// Represents a value of a known or unknown denomination. -// -// Note: unlike some other View types, we don't just store the underlying -// `Value` message together with an additional `Denom`. Instead, we record -// either an `Amount` and `Denom` (only) or an `Amount` and `AssetId`. This is -// because we don't want to allow a situation where the supplied `Denom` doesn't -// match the `AssetId`, and a consumer of the API that doesn't check is tricked. -// This way, the `Denom` will always match, because the consumer is forced to -// recompute it themselves if they want it. -type ValueView struct { - // Types that are valid to be assigned to ValueView: - // - // *ValueView_KnownDenom_ - // *ValueView_UnknownDenom_ - ValueView isValueView_ValueView `protobuf_oneof:"value_view"` -} - -func (m *ValueView) Reset() { *m = ValueView{} } -func (m *ValueView) String() string { return proto.CompactTextString(m) } -func (*ValueView) ProtoMessage() {} -func (*ValueView) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{17} -} -func (m *ValueView) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ValueView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ValueView.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 *ValueView) XXX_Merge(src proto.Message) { - xxx_messageInfo_ValueView.Merge(m, src) -} -func (m *ValueView) XXX_Size() int { - return m.Size() -} -func (m *ValueView) XXX_DiscardUnknown() { - xxx_messageInfo_ValueView.DiscardUnknown(m) -} - -var xxx_messageInfo_ValueView proto.InternalMessageInfo - -type isValueView_ValueView interface { - isValueView_ValueView() - MarshalTo([]byte) (int, error) - Size() int -} - -type ValueView_KnownDenom_ struct { - KnownDenom *ValueView_KnownDenom `protobuf:"bytes,1,opt,name=known_denom,json=knownDenom,proto3,oneof" json:"known_denom,omitempty"` -} -type ValueView_UnknownDenom_ struct { - UnknownDenom *ValueView_UnknownDenom `protobuf:"bytes,2,opt,name=unknown_denom,json=unknownDenom,proto3,oneof" json:"unknown_denom,omitempty"` -} - -func (*ValueView_KnownDenom_) isValueView_ValueView() {} -func (*ValueView_UnknownDenom_) isValueView_ValueView() {} - -func (m *ValueView) GetValueView() isValueView_ValueView { - if m != nil { - return m.ValueView - } - return nil -} - -func (m *ValueView) GetKnownDenom() *ValueView_KnownDenom { - if x, ok := m.GetValueView().(*ValueView_KnownDenom_); ok { - return x.KnownDenom - } - return nil -} - -func (m *ValueView) GetUnknownDenom() *ValueView_UnknownDenom { - if x, ok := m.GetValueView().(*ValueView_UnknownDenom_); ok { - return x.UnknownDenom - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*ValueView) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*ValueView_KnownDenom_)(nil), - (*ValueView_UnknownDenom_)(nil), - } -} - -// A value whose asset ID has a known denomination. -type ValueView_KnownDenom struct { - Amount *Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` - Denom *DenomMetadata `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"` -} - -func (m *ValueView_KnownDenom) Reset() { *m = ValueView_KnownDenom{} } -func (m *ValueView_KnownDenom) String() string { return proto.CompactTextString(m) } -func (*ValueView_KnownDenom) ProtoMessage() {} -func (*ValueView_KnownDenom) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{17, 0} -} -func (m *ValueView_KnownDenom) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ValueView_KnownDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ValueView_KnownDenom.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 *ValueView_KnownDenom) XXX_Merge(src proto.Message) { - xxx_messageInfo_ValueView_KnownDenom.Merge(m, src) -} -func (m *ValueView_KnownDenom) XXX_Size() int { - return m.Size() -} -func (m *ValueView_KnownDenom) XXX_DiscardUnknown() { - xxx_messageInfo_ValueView_KnownDenom.DiscardUnknown(m) -} - -var xxx_messageInfo_ValueView_KnownDenom proto.InternalMessageInfo - -func (m *ValueView_KnownDenom) GetAmount() *Amount { - if m != nil { - return m.Amount - } - return nil -} - -func (m *ValueView_KnownDenom) GetDenom() *DenomMetadata { - if m != nil { - return m.Denom - } - return nil -} - -type ValueView_UnknownDenom struct { - Amount *Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` - AssetId *AssetId `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` -} - -func (m *ValueView_UnknownDenom) Reset() { *m = ValueView_UnknownDenom{} } -func (m *ValueView_UnknownDenom) String() string { return proto.CompactTextString(m) } -func (*ValueView_UnknownDenom) ProtoMessage() {} -func (*ValueView_UnknownDenom) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{17, 1} -} -func (m *ValueView_UnknownDenom) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ValueView_UnknownDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ValueView_UnknownDenom.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 *ValueView_UnknownDenom) XXX_Merge(src proto.Message) { - xxx_messageInfo_ValueView_UnknownDenom.Merge(m, src) -} -func (m *ValueView_UnknownDenom) XXX_Size() int { - return m.Size() -} -func (m *ValueView_UnknownDenom) XXX_DiscardUnknown() { - xxx_messageInfo_ValueView_UnknownDenom.DiscardUnknown(m) -} - -var xxx_messageInfo_ValueView_UnknownDenom proto.InternalMessageInfo - -func (m *ValueView_UnknownDenom) GetAmount() *Amount { - if m != nil { - return m.Amount - } - return nil -} - -func (m *ValueView_UnknownDenom) GetAssetId() *AssetId { - if m != nil { - return m.AssetId - } - return nil -} - -type MerkleRoot struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *MerkleRoot) Reset() { *m = MerkleRoot{} } -func (m *MerkleRoot) String() string { return proto.CompactTextString(m) } -func (*MerkleRoot) ProtoMessage() {} -func (*MerkleRoot) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{18} -} -func (m *MerkleRoot) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MerkleRoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MerkleRoot.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 *MerkleRoot) XXX_Merge(src proto.Message) { - xxx_messageInfo_MerkleRoot.Merge(m, src) -} -func (m *MerkleRoot) XXX_Size() int { - return m.Size() -} -func (m *MerkleRoot) XXX_DiscardUnknown() { - xxx_messageInfo_MerkleRoot.DiscardUnknown(m) -} - -var xxx_messageInfo_MerkleRoot proto.InternalMessageInfo - -func (m *MerkleRoot) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A validator's identity key (decaf377-rdsa spendauth verification key). -type IdentityKey struct { - Ik []byte `protobuf:"bytes,1,opt,name=ik,proto3" json:"ik,omitempty"` -} - -func (m *IdentityKey) Reset() { *m = IdentityKey{} } -func (m *IdentityKey) String() string { return proto.CompactTextString(m) } -func (*IdentityKey) ProtoMessage() {} -func (*IdentityKey) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{19} -} -func (m *IdentityKey) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *IdentityKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_IdentityKey.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 *IdentityKey) XXX_Merge(src proto.Message) { - xxx_messageInfo_IdentityKey.Merge(m, src) -} -func (m *IdentityKey) XXX_Size() int { - return m.Size() -} -func (m *IdentityKey) XXX_DiscardUnknown() { - xxx_messageInfo_IdentityKey.DiscardUnknown(m) -} - -var xxx_messageInfo_IdentityKey proto.InternalMessageInfo - -func (m *IdentityKey) GetIk() []byte { - if m != nil { - return m.Ik - } - return nil -} - -// A validator's governance key (decaf377-rdsa spendauth verification key). -type GovernanceKey struct { - Gk []byte `protobuf:"bytes,1,opt,name=gk,proto3" json:"gk,omitempty"` -} - -func (m *GovernanceKey) Reset() { *m = GovernanceKey{} } -func (m *GovernanceKey) String() string { return proto.CompactTextString(m) } -func (*GovernanceKey) ProtoMessage() {} -func (*GovernanceKey) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{20} -} -func (m *GovernanceKey) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *GovernanceKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_GovernanceKey.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 *GovernanceKey) XXX_Merge(src proto.Message) { - xxx_messageInfo_GovernanceKey.Merge(m, src) -} -func (m *GovernanceKey) XXX_Size() int { - return m.Size() -} -func (m *GovernanceKey) XXX_DiscardUnknown() { - xxx_messageInfo_GovernanceKey.DiscardUnknown(m) -} - -var xxx_messageInfo_GovernanceKey proto.InternalMessageInfo - -func (m *GovernanceKey) GetGk() []byte { - if m != nil { - return m.Gk - } - return nil -} - -type ConsensusKey struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *ConsensusKey) Reset() { *m = ConsensusKey{} } -func (m *ConsensusKey) String() string { return proto.CompactTextString(m) } -func (*ConsensusKey) ProtoMessage() {} -func (*ConsensusKey) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{21} -} -func (m *ConsensusKey) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ConsensusKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ConsensusKey.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 *ConsensusKey) XXX_Merge(src proto.Message) { - xxx_messageInfo_ConsensusKey.Merge(m, src) -} -func (m *ConsensusKey) XXX_Size() int { - return m.Size() -} -func (m *ConsensusKey) XXX_DiscardUnknown() { - xxx_messageInfo_ConsensusKey.DiscardUnknown(m) -} - -var xxx_messageInfo_ConsensusKey proto.InternalMessageInfo - -func (m *ConsensusKey) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type Note struct { - Value *Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` - Rseed []byte `protobuf:"bytes,2,opt,name=rseed,proto3" json:"rseed,omitempty"` - Address *Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` -} - -func (m *Note) Reset() { *m = Note{} } -func (m *Note) String() string { return proto.CompactTextString(m) } -func (*Note) ProtoMessage() {} -func (*Note) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{22} -} -func (m *Note) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Note) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Note.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 *Note) XXX_Merge(src proto.Message) { - xxx_messageInfo_Note.Merge(m, src) -} -func (m *Note) XXX_Size() int { - return m.Size() -} -func (m *Note) XXX_DiscardUnknown() { - xxx_messageInfo_Note.DiscardUnknown(m) -} - -var xxx_messageInfo_Note proto.InternalMessageInfo - -func (m *Note) GetValue() *Value { - if m != nil { - return m.Value - } - return nil -} - -func (m *Note) GetRseed() []byte { - if m != nil { - return m.Rseed - } - return nil -} - -func (m *Note) GetAddress() *Address { - if m != nil { - return m.Address - } - return nil -} - -type NoteView struct { - Value *ValueView `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` - Rseed []byte `protobuf:"bytes,2,opt,name=rseed,proto3" json:"rseed,omitempty"` - Address *AddressView `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` -} - -func (m *NoteView) Reset() { *m = NoteView{} } -func (m *NoteView) String() string { return proto.CompactTextString(m) } -func (*NoteView) ProtoMessage() {} -func (*NoteView) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{23} -} -func (m *NoteView) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *NoteView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_NoteView.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 *NoteView) XXX_Merge(src proto.Message) { - xxx_messageInfo_NoteView.Merge(m, src) -} -func (m *NoteView) XXX_Size() int { - return m.Size() -} -func (m *NoteView) XXX_DiscardUnknown() { - xxx_messageInfo_NoteView.DiscardUnknown(m) -} - -var xxx_messageInfo_NoteView proto.InternalMessageInfo - -func (m *NoteView) GetValue() *ValueView { - if m != nil { - return m.Value - } - return nil -} - -func (m *NoteView) GetRseed() []byte { - if m != nil { - return m.Rseed - } - return nil -} - -func (m *NoteView) GetAddress() *AddressView { - if m != nil { - return m.Address - } - return nil -} - -// An encrypted note. -// 132 = 1(type) + 11(d) + 8(amount) + 32(asset_id) + 32(rcm) + 32(pk_d) + 16(MAC) bytes. -type NoteCiphertext struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *NoteCiphertext) Reset() { *m = NoteCiphertext{} } -func (m *NoteCiphertext) String() string { return proto.CompactTextString(m) } -func (*NoteCiphertext) ProtoMessage() {} -func (*NoteCiphertext) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{24} -} -func (m *NoteCiphertext) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *NoteCiphertext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_NoteCiphertext.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 *NoteCiphertext) XXX_Merge(src proto.Message) { - xxx_messageInfo_NoteCiphertext.Merge(m, src) -} -func (m *NoteCiphertext) XXX_Size() int { - return m.Size() -} -func (m *NoteCiphertext) XXX_DiscardUnknown() { - xxx_messageInfo_NoteCiphertext.DiscardUnknown(m) -} - -var xxx_messageInfo_NoteCiphertext proto.InternalMessageInfo - -func (m *NoteCiphertext) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type Nullifier struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *Nullifier) Reset() { *m = Nullifier{} } -func (m *Nullifier) String() string { return proto.CompactTextString(m) } -func (*Nullifier) ProtoMessage() {} -func (*Nullifier) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{25} -} -func (m *Nullifier) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Nullifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Nullifier.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 *Nullifier) XXX_Merge(src proto.Message) { - xxx_messageInfo_Nullifier.Merge(m, src) -} -func (m *Nullifier) XXX_Size() int { - return m.Size() -} -func (m *Nullifier) XXX_DiscardUnknown() { - xxx_messageInfo_Nullifier.DiscardUnknown(m) -} - -var xxx_messageInfo_Nullifier proto.InternalMessageInfo - -func (m *Nullifier) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type SpendAuthSignature struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *SpendAuthSignature) Reset() { *m = SpendAuthSignature{} } -func (m *SpendAuthSignature) String() string { return proto.CompactTextString(m) } -func (*SpendAuthSignature) ProtoMessage() {} -func (*SpendAuthSignature) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{26} -} -func (m *SpendAuthSignature) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SpendAuthSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SpendAuthSignature.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 *SpendAuthSignature) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpendAuthSignature.Merge(m, src) -} -func (m *SpendAuthSignature) XXX_Size() int { - return m.Size() -} -func (m *SpendAuthSignature) XXX_DiscardUnknown() { - xxx_messageInfo_SpendAuthSignature.DiscardUnknown(m) -} - -var xxx_messageInfo_SpendAuthSignature proto.InternalMessageInfo - -func (m *SpendAuthSignature) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -type BindingSignature struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *BindingSignature) Reset() { *m = BindingSignature{} } -func (m *BindingSignature) String() string { return proto.CompactTextString(m) } -func (*BindingSignature) ProtoMessage() {} -func (*BindingSignature) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{27} -} -func (m *BindingSignature) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *BindingSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_BindingSignature.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 *BindingSignature) XXX_Merge(src proto.Message) { - xxx_messageInfo_BindingSignature.Merge(m, src) -} -func (m *BindingSignature) XXX_Size() int { - return m.Size() -} -func (m *BindingSignature) XXX_DiscardUnknown() { - xxx_messageInfo_BindingSignature.DiscardUnknown(m) -} - -var xxx_messageInfo_BindingSignature proto.InternalMessageInfo - -func (m *BindingSignature) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// The body of an output description, including only the minimal -// data required to scan and process the output. -type NotePayload struct { - // The note commitment for the output note. 32 bytes. - NoteCommitment *StateCommitment `protobuf:"bytes,1,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` - // The encoding of an ephemeral public key. 32 bytes. - EphemeralKey []byte `protobuf:"bytes,2,opt,name=ephemeral_key,json=ephemeralKey,proto3" json:"ephemeral_key,omitempty"` - // An encryption of the newly created note. - // 132 = 1(type) + 11(d) + 8(amount) + 32(asset_id) + 32(rcm) + 32(pk_d) + 16(MAC) bytes. - EncryptedNote *NoteCiphertext `protobuf:"bytes,3,opt,name=encrypted_note,json=encryptedNote,proto3" json:"encrypted_note,omitempty"` -} - -func (m *NotePayload) Reset() { *m = NotePayload{} } -func (m *NotePayload) String() string { return proto.CompactTextString(m) } -func (*NotePayload) ProtoMessage() {} -func (*NotePayload) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{28} -} -func (m *NotePayload) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *NotePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_NotePayload.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 *NotePayload) XXX_Merge(src proto.Message) { - xxx_messageInfo_NotePayload.Merge(m, src) -} -func (m *NotePayload) XXX_Size() int { - return m.Size() -} -func (m *NotePayload) XXX_DiscardUnknown() { - xxx_messageInfo_NotePayload.DiscardUnknown(m) -} - -var xxx_messageInfo_NotePayload proto.InternalMessageInfo - -func (m *NotePayload) GetNoteCommitment() *StateCommitment { - if m != nil { - return m.NoteCommitment - } - return nil -} - -func (m *NotePayload) GetEphemeralKey() []byte { - if m != nil { - return m.EphemeralKey - } - return nil -} - -func (m *NotePayload) GetEncryptedNote() *NoteCiphertext { - if m != nil { - return m.EncryptedNote - } - return nil -} - -// An authentication path from a state commitment to the root of the state commitment tree. -type StateCommitmentProof struct { - NoteCommitment *StateCommitment `protobuf:"bytes,1,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` - Position uint64 `protobuf:"varint,2,opt,name=position,proto3" json:"position,omitempty"` - AuthPath []*MerklePathChunk `protobuf:"bytes,3,rep,name=auth_path,json=authPath,proto3" json:"auth_path,omitempty"` -} - -func (m *StateCommitmentProof) Reset() { *m = StateCommitmentProof{} } -func (m *StateCommitmentProof) String() string { return proto.CompactTextString(m) } -func (*StateCommitmentProof) ProtoMessage() {} -func (*StateCommitmentProof) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{29} -} -func (m *StateCommitmentProof) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StateCommitmentProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StateCommitmentProof.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 *StateCommitmentProof) XXX_Merge(src proto.Message) { - xxx_messageInfo_StateCommitmentProof.Merge(m, src) -} -func (m *StateCommitmentProof) XXX_Size() int { - return m.Size() -} -func (m *StateCommitmentProof) XXX_DiscardUnknown() { - xxx_messageInfo_StateCommitmentProof.DiscardUnknown(m) -} - -var xxx_messageInfo_StateCommitmentProof proto.InternalMessageInfo - -func (m *StateCommitmentProof) GetNoteCommitment() *StateCommitment { - if m != nil { - return m.NoteCommitment - } - return nil -} - -func (m *StateCommitmentProof) GetPosition() uint64 { - if m != nil { - return m.Position - } - return 0 -} - -func (m *StateCommitmentProof) GetAuthPath() []*MerklePathChunk { - if m != nil { - return m.AuthPath - } - return nil -} - -// A set of 3 sibling hashes in the auth path for some note commitment. -type MerklePathChunk struct { - Sibling_1 []byte `protobuf:"bytes,1,opt,name=sibling_1,json=sibling1,proto3" json:"sibling_1,omitempty"` - Sibling_2 []byte `protobuf:"bytes,2,opt,name=sibling_2,json=sibling2,proto3" json:"sibling_2,omitempty"` - Sibling_3 []byte `protobuf:"bytes,3,opt,name=sibling_3,json=sibling3,proto3" json:"sibling_3,omitempty"` -} - -func (m *MerklePathChunk) Reset() { *m = MerklePathChunk{} } -func (m *MerklePathChunk) String() string { return proto.CompactTextString(m) } -func (*MerklePathChunk) ProtoMessage() {} -func (*MerklePathChunk) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{30} -} -func (m *MerklePathChunk) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MerklePathChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MerklePathChunk.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 *MerklePathChunk) XXX_Merge(src proto.Message) { - xxx_messageInfo_MerklePathChunk.Merge(m, src) -} -func (m *MerklePathChunk) XXX_Size() int { - return m.Size() -} -func (m *MerklePathChunk) XXX_DiscardUnknown() { - xxx_messageInfo_MerklePathChunk.DiscardUnknown(m) -} - -var xxx_messageInfo_MerklePathChunk proto.InternalMessageInfo - -func (m *MerklePathChunk) GetSibling_1() []byte { - if m != nil { - return m.Sibling_1 - } - return nil -} - -func (m *MerklePathChunk) GetSibling_2() []byte { - if m != nil { - return m.Sibling_2 - } - return nil -} - -func (m *MerklePathChunk) GetSibling_3() []byte { - if m != nil { - return m.Sibling_3 - } - return nil -} - -// A clue for use with Fuzzy Message Detection. -type Clue struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *Clue) Reset() { *m = Clue{} } -func (m *Clue) String() string { return proto.CompactTextString(m) } -func (*Clue) ProtoMessage() {} -func (*Clue) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{31} -} -func (m *Clue) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Clue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Clue.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 *Clue) XXX_Merge(src proto.Message) { - xxx_messageInfo_Clue.Merge(m, src) -} -func (m *Clue) XXX_Size() int { - return m.Size() -} -func (m *Clue) XXX_DiscardUnknown() { - xxx_messageInfo_Clue.DiscardUnknown(m) -} - -var xxx_messageInfo_Clue proto.InternalMessageInfo - -func (m *Clue) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// An authorization hash for a Penumbra transaction. -type EffectHash struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *EffectHash) Reset() { *m = EffectHash{} } -func (m *EffectHash) String() string { return proto.CompactTextString(m) } -func (*EffectHash) ProtoMessage() {} -func (*EffectHash) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{32} -} -func (m *EffectHash) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *EffectHash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_EffectHash.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 *EffectHash) XXX_Merge(src proto.Message) { - xxx_messageInfo_EffectHash.Merge(m, src) -} -func (m *EffectHash) XXX_Size() int { - return m.Size() -} -func (m *EffectHash) XXX_DiscardUnknown() { - xxx_messageInfo_EffectHash.DiscardUnknown(m) -} - -var xxx_messageInfo_EffectHash proto.InternalMessageInfo - -func (m *EffectHash) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A Penumbra ZK output proof. -type ZKOutputProof struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *ZKOutputProof) Reset() { *m = ZKOutputProof{} } -func (m *ZKOutputProof) String() string { return proto.CompactTextString(m) } -func (*ZKOutputProof) ProtoMessage() {} -func (*ZKOutputProof) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{33} -} -func (m *ZKOutputProof) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ZKOutputProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ZKOutputProof.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 *ZKOutputProof) XXX_Merge(src proto.Message) { - xxx_messageInfo_ZKOutputProof.Merge(m, src) -} -func (m *ZKOutputProof) XXX_Size() int { - return m.Size() -} -func (m *ZKOutputProof) XXX_DiscardUnknown() { - xxx_messageInfo_ZKOutputProof.DiscardUnknown(m) -} - -var xxx_messageInfo_ZKOutputProof proto.InternalMessageInfo - -func (m *ZKOutputProof) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A Penumbra ZK spend proof. -type ZKSpendProof struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *ZKSpendProof) Reset() { *m = ZKSpendProof{} } -func (m *ZKSpendProof) String() string { return proto.CompactTextString(m) } -func (*ZKSpendProof) ProtoMessage() {} -func (*ZKSpendProof) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{34} -} -func (m *ZKSpendProof) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ZKSpendProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ZKSpendProof.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 *ZKSpendProof) XXX_Merge(src proto.Message) { - xxx_messageInfo_ZKSpendProof.Merge(m, src) -} -func (m *ZKSpendProof) XXX_Size() int { - return m.Size() -} -func (m *ZKSpendProof) XXX_DiscardUnknown() { - xxx_messageInfo_ZKSpendProof.DiscardUnknown(m) -} - -var xxx_messageInfo_ZKSpendProof proto.InternalMessageInfo - -func (m *ZKSpendProof) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A Penumbra ZK swap proof. -type ZKSwapProof struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *ZKSwapProof) Reset() { *m = ZKSwapProof{} } -func (m *ZKSwapProof) String() string { return proto.CompactTextString(m) } -func (*ZKSwapProof) ProtoMessage() {} -func (*ZKSwapProof) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{35} -} -func (m *ZKSwapProof) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ZKSwapProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ZKSwapProof.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 *ZKSwapProof) XXX_Merge(src proto.Message) { - xxx_messageInfo_ZKSwapProof.Merge(m, src) -} -func (m *ZKSwapProof) XXX_Size() int { - return m.Size() -} -func (m *ZKSwapProof) XXX_DiscardUnknown() { - xxx_messageInfo_ZKSwapProof.DiscardUnknown(m) -} - -var xxx_messageInfo_ZKSwapProof proto.InternalMessageInfo - -func (m *ZKSwapProof) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A Penumbra ZK swap claim proof. -type ZKSwapClaimProof struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *ZKSwapClaimProof) Reset() { *m = ZKSwapClaimProof{} } -func (m *ZKSwapClaimProof) String() string { return proto.CompactTextString(m) } -func (*ZKSwapClaimProof) ProtoMessage() {} -func (*ZKSwapClaimProof) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{36} -} -func (m *ZKSwapClaimProof) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ZKSwapClaimProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ZKSwapClaimProof.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 *ZKSwapClaimProof) XXX_Merge(src proto.Message) { - xxx_messageInfo_ZKSwapClaimProof.Merge(m, src) -} -func (m *ZKSwapClaimProof) XXX_Size() int { - return m.Size() -} -func (m *ZKSwapClaimProof) XXX_DiscardUnknown() { - xxx_messageInfo_ZKSwapClaimProof.DiscardUnknown(m) -} - -var xxx_messageInfo_ZKSwapClaimProof proto.InternalMessageInfo - -func (m *ZKSwapClaimProof) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A Penumbra ZK undelegate claim proof. -type ZKUndelegateClaimProof struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *ZKUndelegateClaimProof) Reset() { *m = ZKUndelegateClaimProof{} } -func (m *ZKUndelegateClaimProof) String() string { return proto.CompactTextString(m) } -func (*ZKUndelegateClaimProof) ProtoMessage() {} -func (*ZKUndelegateClaimProof) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{37} -} -func (m *ZKUndelegateClaimProof) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ZKUndelegateClaimProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ZKUndelegateClaimProof.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 *ZKUndelegateClaimProof) XXX_Merge(src proto.Message) { - xxx_messageInfo_ZKUndelegateClaimProof.Merge(m, src) -} -func (m *ZKUndelegateClaimProof) XXX_Size() int { - return m.Size() -} -func (m *ZKUndelegateClaimProof) XXX_DiscardUnknown() { - xxx_messageInfo_ZKUndelegateClaimProof.DiscardUnknown(m) -} - -var xxx_messageInfo_ZKUndelegateClaimProof proto.InternalMessageInfo - -func (m *ZKUndelegateClaimProof) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A Penumbra ZK delegator vote proof. -type ZKDelegatorVoteProof struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *ZKDelegatorVoteProof) Reset() { *m = ZKDelegatorVoteProof{} } -func (m *ZKDelegatorVoteProof) String() string { return proto.CompactTextString(m) } -func (*ZKDelegatorVoteProof) ProtoMessage() {} -func (*ZKDelegatorVoteProof) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{38} -} -func (m *ZKDelegatorVoteProof) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ZKDelegatorVoteProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ZKDelegatorVoteProof.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 *ZKDelegatorVoteProof) XXX_Merge(src proto.Message) { - xxx_messageInfo_ZKDelegatorVoteProof.Merge(m, src) -} -func (m *ZKDelegatorVoteProof) XXX_Size() int { - return m.Size() -} -func (m *ZKDelegatorVoteProof) XXX_DiscardUnknown() { - xxx_messageInfo_ZKDelegatorVoteProof.DiscardUnknown(m) -} - -var xxx_messageInfo_ZKDelegatorVoteProof proto.InternalMessageInfo - -func (m *ZKDelegatorVoteProof) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -// A Penumbra ZK nullifier derivation proof. -type ZKNullifierDerivationProof struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *ZKNullifierDerivationProof) Reset() { *m = ZKNullifierDerivationProof{} } -func (m *ZKNullifierDerivationProof) String() string { return proto.CompactTextString(m) } -func (*ZKNullifierDerivationProof) ProtoMessage() {} -func (*ZKNullifierDerivationProof) Descriptor() ([]byte, []int) { - return fileDescriptor_5c23a0b4440af102, []int{39} -} -func (m *ZKNullifierDerivationProof) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ZKNullifierDerivationProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ZKNullifierDerivationProof.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 *ZKNullifierDerivationProof) XXX_Merge(src proto.Message) { - xxx_messageInfo_ZKNullifierDerivationProof.Merge(m, src) -} -func (m *ZKNullifierDerivationProof) XXX_Size() int { - return m.Size() -} -func (m *ZKNullifierDerivationProof) XXX_DiscardUnknown() { - xxx_messageInfo_ZKNullifierDerivationProof.DiscardUnknown(m) -} - -var xxx_messageInfo_ZKNullifierDerivationProof proto.InternalMessageInfo - -func (m *ZKNullifierDerivationProof) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -func init() { - proto.RegisterType((*Fee)(nil), "penumbra.core.crypto.v1alpha1.Fee") - proto.RegisterType((*Address)(nil), "penumbra.core.crypto.v1alpha1.Address") - proto.RegisterType((*AddressView)(nil), "penumbra.core.crypto.v1alpha1.AddressView") - proto.RegisterType((*AddressView_Visible)(nil), "penumbra.core.crypto.v1alpha1.AddressView.Visible") - proto.RegisterType((*AddressView_Opaque)(nil), "penumbra.core.crypto.v1alpha1.AddressView.Opaque") - proto.RegisterType((*SpendKey)(nil), "penumbra.core.crypto.v1alpha1.SpendKey") - proto.RegisterType((*SpendVerificationKey)(nil), "penumbra.core.crypto.v1alpha1.SpendVerificationKey") - proto.RegisterType((*FullViewingKey)(nil), "penumbra.core.crypto.v1alpha1.FullViewingKey") - proto.RegisterType((*AccountGroupId)(nil), "penumbra.core.crypto.v1alpha1.AccountGroupId") - proto.RegisterType((*Diversifier)(nil), "penumbra.core.crypto.v1alpha1.Diversifier") - proto.RegisterType((*AddressIndex)(nil), "penumbra.core.crypto.v1alpha1.AddressIndex") - proto.RegisterType((*StateCommitment)(nil), "penumbra.core.crypto.v1alpha1.StateCommitment") - proto.RegisterType((*BalanceCommitment)(nil), "penumbra.core.crypto.v1alpha1.BalanceCommitment") - proto.RegisterType((*AssetId)(nil), "penumbra.core.crypto.v1alpha1.AssetId") - proto.RegisterType((*Amount)(nil), "penumbra.core.crypto.v1alpha1.Amount") - proto.RegisterType((*Denom)(nil), "penumbra.core.crypto.v1alpha1.Denom") - proto.RegisterType((*DenomMetadata)(nil), "penumbra.core.crypto.v1alpha1.DenomMetadata") - proto.RegisterType((*DenomUnit)(nil), "penumbra.core.crypto.v1alpha1.DenomUnit") - proto.RegisterType((*Value)(nil), "penumbra.core.crypto.v1alpha1.Value") - proto.RegisterType((*ValueView)(nil), "penumbra.core.crypto.v1alpha1.ValueView") - proto.RegisterType((*ValueView_KnownDenom)(nil), "penumbra.core.crypto.v1alpha1.ValueView.KnownDenom") - proto.RegisterType((*ValueView_UnknownDenom)(nil), "penumbra.core.crypto.v1alpha1.ValueView.UnknownDenom") - proto.RegisterType((*MerkleRoot)(nil), "penumbra.core.crypto.v1alpha1.MerkleRoot") - proto.RegisterType((*IdentityKey)(nil), "penumbra.core.crypto.v1alpha1.IdentityKey") - proto.RegisterType((*GovernanceKey)(nil), "penumbra.core.crypto.v1alpha1.GovernanceKey") - proto.RegisterType((*ConsensusKey)(nil), "penumbra.core.crypto.v1alpha1.ConsensusKey") - proto.RegisterType((*Note)(nil), "penumbra.core.crypto.v1alpha1.Note") - proto.RegisterType((*NoteView)(nil), "penumbra.core.crypto.v1alpha1.NoteView") - proto.RegisterType((*NoteCiphertext)(nil), "penumbra.core.crypto.v1alpha1.NoteCiphertext") - proto.RegisterType((*Nullifier)(nil), "penumbra.core.crypto.v1alpha1.Nullifier") - proto.RegisterType((*SpendAuthSignature)(nil), "penumbra.core.crypto.v1alpha1.SpendAuthSignature") - proto.RegisterType((*BindingSignature)(nil), "penumbra.core.crypto.v1alpha1.BindingSignature") - proto.RegisterType((*NotePayload)(nil), "penumbra.core.crypto.v1alpha1.NotePayload") - proto.RegisterType((*StateCommitmentProof)(nil), "penumbra.core.crypto.v1alpha1.StateCommitmentProof") - proto.RegisterType((*MerklePathChunk)(nil), "penumbra.core.crypto.v1alpha1.MerklePathChunk") - proto.RegisterType((*Clue)(nil), "penumbra.core.crypto.v1alpha1.Clue") - proto.RegisterType((*EffectHash)(nil), "penumbra.core.crypto.v1alpha1.EffectHash") - proto.RegisterType((*ZKOutputProof)(nil), "penumbra.core.crypto.v1alpha1.ZKOutputProof") - proto.RegisterType((*ZKSpendProof)(nil), "penumbra.core.crypto.v1alpha1.ZKSpendProof") - proto.RegisterType((*ZKSwapProof)(nil), "penumbra.core.crypto.v1alpha1.ZKSwapProof") - proto.RegisterType((*ZKSwapClaimProof)(nil), "penumbra.core.crypto.v1alpha1.ZKSwapClaimProof") - proto.RegisterType((*ZKUndelegateClaimProof)(nil), "penumbra.core.crypto.v1alpha1.ZKUndelegateClaimProof") - proto.RegisterType((*ZKDelegatorVoteProof)(nil), "penumbra.core.crypto.v1alpha1.ZKDelegatorVoteProof") - proto.RegisterType((*ZKNullifierDerivationProof)(nil), "penumbra.core.crypto.v1alpha1.ZKNullifierDerivationProof") -} - -func init() { - proto.RegisterFile("penumbra/core/crypto/v1alpha1/crypto.proto", fileDescriptor_5c23a0b4440af102) -} - -var fileDescriptor_5c23a0b4440af102 = []byte{ - // 1437 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x6e, 0x1b, 0xb7, - 0x16, 0xf6, 0x48, 0xb6, 0x25, 0x1f, 0xc9, 0xb2, 0x43, 0x18, 0x81, 0xae, 0xef, 0xb5, 0xe3, 0x4c, - 0x1c, 0x5f, 0x27, 0x37, 0x57, 0x86, 0x65, 0x74, 0xe3, 0xa2, 0x45, 0x2c, 0xb9, 0x89, 0x5d, 0x21, - 0x89, 0x30, 0x6e, 0x9c, 0x42, 0x30, 0x20, 0xd0, 0x33, 0xb4, 0x86, 0xd0, 0x0c, 0x39, 0x9d, 0x1f, - 0x39, 0xea, 0x0b, 0x14, 0x5d, 0x35, 0xeb, 0x2e, 0xbb, 0xe8, 0xa2, 0x6f, 0xd0, 0x5d, 0x97, 0x45, - 0x57, 0x59, 0x66, 0xd9, 0x3a, 0x8b, 0x02, 0x5d, 0x75, 0xd1, 0x07, 0x28, 0xc8, 0xe1, 0xc8, 0xb2, - 0x61, 0xfd, 0x24, 0x41, 0xd1, 0xee, 0x78, 0x78, 0xbe, 0xf3, 0xf1, 0xe3, 0x39, 0xe4, 0x1c, 0x4a, - 0x70, 0xd7, 0x23, 0x2c, 0x72, 0x8f, 0x7d, 0xbc, 0x61, 0x72, 0x9f, 0x6c, 0x98, 0x7e, 0xd7, 0x0b, - 0xf9, 0x46, 0x67, 0x13, 0x3b, 0x9e, 0x8d, 0x37, 0x95, 0x5d, 0xf2, 0x7c, 0x1e, 0x72, 0xb4, 0x94, - 0x60, 0x4b, 0x02, 0x5b, 0x52, 0xbe, 0x04, 0xab, 0x7f, 0xa1, 0x41, 0xfa, 0x01, 0x21, 0xe8, 0x03, - 0x98, 0xc6, 0x2e, 0x8f, 0x58, 0x58, 0xd4, 0x56, 0xb4, 0xf5, 0x5c, 0xf9, 0x76, 0x69, 0x68, 0x5c, - 0x69, 0x47, 0x82, 0x0d, 0x15, 0x84, 0x76, 0x20, 0x8b, 0x83, 0x80, 0x84, 0x4d, 0x6a, 0x15, 0x53, - 0x92, 0x60, 0x6d, 0x14, 0x81, 0x80, 0xef, 0x5b, 0x46, 0x06, 0xc7, 0x03, 0xfd, 0x3e, 0x64, 0x76, - 0x2c, 0xcb, 0x27, 0x41, 0x80, 0x16, 0x60, 0x8a, 0x32, 0x46, 0x7c, 0xa9, 0x25, 0x6f, 0xc4, 0x06, - 0xba, 0x01, 0x39, 0xec, 0x84, 0xcd, 0x63, 0x62, 0xda, 0x5b, 0x65, 0x57, 0x2e, 0x33, 0x63, 0x00, - 0x76, 0xc2, 0x4a, 0x3c, 0xa3, 0xff, 0x9e, 0x86, 0x9c, 0xa2, 0x38, 0xa4, 0xe4, 0x14, 0x3d, 0x86, - 0x4c, 0x87, 0x06, 0xf4, 0xd8, 0x21, 0x6a, 0x53, 0xe5, 0x51, 0x9a, 0xce, 0x83, 0x4b, 0x87, 0x71, - 0xe4, 0xde, 0x84, 0x91, 0x90, 0xa0, 0x1a, 0x4c, 0x73, 0x0f, 0x7f, 0x16, 0x11, 0xb5, 0xc5, 0xcd, - 0x37, 0xa0, 0x7b, 0x22, 0x03, 0xf7, 0x26, 0x0c, 0x45, 0xb1, 0xf8, 0xab, 0x06, 0x19, 0xb5, 0x06, - 0xba, 0x0f, 0x19, 0x1c, 0x63, 0x95, 0xd0, 0xb5, 0xf1, 0x98, 0x8d, 0x24, 0x0c, 0xed, 0x88, 0x8c, - 0x59, 0xe4, 0xb9, 0x52, 0xf6, 0xbf, 0xf1, 0xe2, 0xf7, 0x45, 0x88, 0x11, 0x47, 0xa2, 0x67, 0x30, - 0x8f, 0x4d, 0x53, 0x54, 0xb3, 0xd9, 0xf2, 0x79, 0xe4, 0x89, 0x52, 0xa6, 0x25, 0xdb, 0xff, 0x47, - 0xb1, 0xc5, 0x61, 0x0f, 0x45, 0xd4, 0xbe, 0x65, 0x14, 0xf0, 0x05, 0x7b, 0xf1, 0x63, 0x98, 0x8e, - 0x77, 0xff, 0xee, 0xfb, 0xac, 0x14, 0x20, 0xaf, 0x86, 0xcd, 0x0e, 0x25, 0xa7, 0xfa, 0x0a, 0x64, - 0x0f, 0x3c, 0xc2, 0xac, 0x1a, 0xe9, 0x5e, 0x7d, 0x6a, 0xf4, 0x7b, 0xb0, 0x20, 0x11, 0x87, 0xc4, - 0xa7, 0x27, 0xd4, 0xc4, 0x21, 0xe5, 0x6c, 0x30, 0x7a, 0x0d, 0x0a, 0x0f, 0x22, 0xc7, 0x11, 0x25, - 0xa3, 0xac, 0x35, 0x14, 0x77, 0x71, 0xd7, 0x03, 0x70, 0xb7, 0x20, 0xb7, 0x4b, 0x3b, 0xc4, 0x0f, - 0xe8, 0x09, 0x25, 0xfe, 0x00, 0xd0, 0x1e, 0xe4, 0xfb, 0x0b, 0x82, 0x8a, 0x90, 0x51, 0x29, 0x94, - 0xe5, 0x9c, 0x35, 0x12, 0x13, 0x2d, 0x03, 0xf8, 0x98, 0x59, 0xdc, 0xa5, 0x9f, 0x13, 0x5f, 0x56, - 0x27, 0x6f, 0xf4, 0xcd, 0xe8, 0xff, 0x85, 0xb9, 0x83, 0x10, 0x87, 0xa4, 0xca, 0x5d, 0x97, 0x86, - 0x2e, 0x61, 0xe1, 0x80, 0x25, 0xef, 0xc0, 0xb5, 0x0a, 0x76, 0x30, 0x33, 0x47, 0x43, 0x4f, 0x20, - 0xa3, 0xee, 0xea, 0x5b, 0xde, 0x4b, 0xb4, 0x0a, 0x05, 0x09, 0xc0, 0x01, 0x69, 0x5a, 0x84, 0x71, - 0x57, 0x2a, 0x9f, 0x31, 0xf2, 0x02, 0x83, 0x03, 0xb2, 0x2b, 0xe6, 0xf4, 0x75, 0x98, 0x8e, 0x3f, - 0x2a, 0xa8, 0x00, 0x29, 0x87, 0xcb, 0x35, 0x26, 0x8d, 0x94, 0xc3, 0x85, 0x6d, 0x53, 0xc9, 0x3b, - 0x69, 0xa4, 0x6c, 0xaa, 0x2f, 0xc1, 0x94, 0x0c, 0x11, 0x7a, 0x62, 0x3e, 0x4d, 0xf2, 0xc5, 0x86, - 0xfe, 0x2a, 0x05, 0xb3, 0xd2, 0xff, 0x88, 0x84, 0xd8, 0xc2, 0x21, 0x46, 0x2b, 0x90, 0xb3, 0x48, - 0x60, 0xfa, 0xd4, 0x13, 0xd5, 0x57, 0xe8, 0xfe, 0x29, 0xb4, 0x2f, 0x10, 0x8c, 0xbb, 0xcd, 0x88, - 0xd1, 0x30, 0x28, 0xa6, 0x56, 0xd2, 0xeb, 0xb9, 0xf2, 0xfa, 0x88, 0xd3, 0x29, 0x17, 0x79, 0xca, - 0x68, 0x68, 0x80, 0x95, 0x0c, 0x03, 0x84, 0x60, 0x52, 0xec, 0x54, 0xed, 0x51, 0x8e, 0x45, 0x45, - 0x2d, 0x1a, 0x78, 0x0e, 0xee, 0x16, 0x27, 0xe5, 0x74, 0x62, 0x0a, 0x34, 0xc3, 0x2e, 0x29, 0x4e, - 0xc5, 0x68, 0x31, 0x46, 0xd7, 0x61, 0x3a, 0xe8, 0xba, 0xc7, 0xdc, 0x29, 0x4e, 0xcb, 0x59, 0x65, - 0xa1, 0x79, 0x48, 0x47, 0x3e, 0x2d, 0x66, 0xe4, 0xa4, 0x18, 0xa2, 0x7f, 0x41, 0x36, 0xf2, 0x69, - 0xd3, 0xc6, 0x81, 0x5d, 0xcc, 0xc6, 0xc4, 0x91, 0x4f, 0xf7, 0x70, 0x60, 0xa3, 0x03, 0xb8, 0x96, - 0xa8, 0x6f, 0xf6, 0x3e, 0xcd, 0x3f, 0xcc, 0xbd, 0xd1, 0xb7, 0x79, 0x2e, 0x81, 0xa9, 0x09, 0xfd, - 0x19, 0xcc, 0xf4, 0x36, 0x7d, 0x75, 0xf6, 0xd1, 0x22, 0x64, 0xc9, 0x73, 0x8f, 0x33, 0xd2, 0x3b, - 0xbd, 0x3d, 0x5b, 0x1e, 0x6c, 0x87, 0xe2, 0x80, 0x04, 0xc5, 0xf4, 0x4a, 0x5a, 0xa8, 0x55, 0xa6, - 0xfe, 0xa5, 0x06, 0x53, 0x87, 0xd8, 0x89, 0xfe, 0x09, 0x8d, 0xe8, 0x8f, 0x34, 0xcc, 0x48, 0x2d, - 0xb2, 0x89, 0x1c, 0x42, 0xae, 0xcd, 0xf8, 0x29, 0x6b, 0x9e, 0xef, 0x35, 0x57, 0xde, 0x1a, 0xc1, - 0xd9, 0x0b, 0x2f, 0xd5, 0x44, 0xac, 0xcc, 0xd9, 0xde, 0x84, 0x01, 0xed, 0x9e, 0x85, 0x8e, 0x60, - 0x36, 0x62, 0xfd, 0xcc, 0xb1, 0xda, 0xf7, 0xc6, 0x66, 0x7e, 0xca, 0xda, 0xfd, 0xdc, 0xf9, 0xa8, - 0xcf, 0x5e, 0xfc, 0x4a, 0x03, 0x38, 0x5f, 0xfa, 0x5d, 0x93, 0x5a, 0x49, 0x2a, 0x1d, 0x6b, 0xbc, - 0x37, 0xce, 0xbd, 0x48, 0x2e, 0x9f, 0x3a, 0x17, 0x8b, 0x2f, 0x34, 0xc8, 0xf7, 0x4b, 0xfe, 0xfb, - 0x0b, 0x5d, 0xc9, 0x03, 0x74, 0x44, 0x3a, 0xe3, 0x56, 0xa2, 0x03, 0x3c, 0x22, 0x7e, 0xdb, 0x21, - 0x06, 0xe7, 0x83, 0xbe, 0x85, 0x4b, 0x90, 0xdb, 0xb7, 0x08, 0x0b, 0x69, 0xd8, 0x15, 0xbd, 0xa1, - 0x00, 0x29, 0xda, 0x56, 0x88, 0x14, 0x6d, 0xeb, 0x37, 0x60, 0xf6, 0x21, 0xef, 0x10, 0x9f, 0x89, - 0x0f, 0xab, 0x02, 0xb4, 0x7a, 0x80, 0x56, 0x5b, 0x5f, 0x85, 0x7c, 0x95, 0xb3, 0x80, 0xb0, 0x20, - 0x0a, 0x06, 0x37, 0x97, 0xaf, 0x35, 0x98, 0x7c, 0xcc, 0x43, 0x82, 0xb6, 0x61, 0x4a, 0x0a, 0x54, - 0x19, 0x5a, 0x1d, 0xe7, 0x6c, 0x18, 0x71, 0x88, 0xa0, 0xf6, 0x03, 0x42, 0xe2, 0xe4, 0xe4, 0x8d, - 0xd8, 0xe8, 0xef, 0xc0, 0xe9, 0xb7, 0xea, 0xc0, 0xfa, 0xb7, 0x1a, 0x64, 0x85, 0x38, 0x79, 0x39, - 0x3e, 0xbc, 0x28, 0x70, 0x7d, 0xdc, 0xc3, 0x3b, 0x5c, 0xe4, 0xee, 0x65, 0x91, 0x77, 0xc7, 0x7f, - 0x68, 0x9d, 0x0b, 0x5d, 0x83, 0x82, 0xd0, 0x59, 0xa5, 0x9e, 0x4d, 0xfc, 0x90, 0x3c, 0x1f, 0x54, - 0xd3, 0x9b, 0x30, 0xf3, 0x38, 0x72, 0x9c, 0x61, 0x0d, 0xfa, 0x2e, 0x20, 0xf9, 0x86, 0xd8, 0x89, - 0x42, 0xfb, 0x80, 0xb6, 0x18, 0x0e, 0x23, 0x9f, 0x0c, 0xc0, 0xae, 0xc3, 0x7c, 0x85, 0x32, 0x8b, - 0xb2, 0xd6, 0x28, 0xe4, 0x2f, 0x1a, 0xe4, 0x84, 0xc2, 0x3a, 0xee, 0x3a, 0x1c, 0x5b, 0xe8, 0x19, - 0xcc, 0x31, 0x1e, 0x92, 0xa6, 0xd9, 0xeb, 0xc8, 0x2a, 0xad, 0xa5, 0x11, 0xdb, 0xbf, 0xd4, 0xf2, - 0x8d, 0x82, 0xa0, 0xe9, 0xeb, 0xeb, 0xb7, 0x60, 0x96, 0x78, 0x36, 0x71, 0x89, 0x8f, 0x9d, 0x66, - 0x9b, 0x74, 0x55, 0xb6, 0xf3, 0xbd, 0x49, 0x71, 0x14, 0x3f, 0x81, 0x02, 0x61, 0x92, 0x99, 0x58, - 0x4d, 0x41, 0x30, 0xe6, 0xe3, 0xef, 0x62, 0x8e, 0x8d, 0xd9, 0x1e, 0x89, 0x70, 0xe8, 0xaf, 0x34, - 0x58, 0xb8, 0x24, 0xaf, 0xee, 0x73, 0x7e, 0xf2, 0xd7, 0x6d, 0x76, 0x11, 0xb2, 0x1e, 0x0f, 0xa8, - 0x6c, 0xf4, 0xf1, 0x93, 0xa1, 0x67, 0xa3, 0x1a, 0xcc, 0xe0, 0x28, 0xb4, 0x9b, 0x1e, 0x0e, 0x6d, - 0xd9, 0x81, 0x46, 0x2f, 0x17, 0x7f, 0x12, 0xea, 0x38, 0xb4, 0xab, 0x76, 0xc4, 0xda, 0x46, 0x56, - 0x10, 0x08, 0x53, 0xb7, 0x61, 0xee, 0x92, 0x13, 0xfd, 0x1b, 0x66, 0xc4, 0x83, 0x9e, 0xb2, 0x56, - 0x73, 0x53, 0xd5, 0x3a, 0xab, 0x26, 0x36, 0xfb, 0x9d, 0x65, 0x55, 0x81, 0xc4, 0x59, 0xee, 0x77, - 0x6e, 0xa9, 0x77, 0x5d, 0xe2, 0xdc, 0xd2, 0xff, 0x03, 0x93, 0x55, 0x75, 0x5b, 0xae, 0x38, 0x46, - 0x3a, 0xc0, 0x47, 0x27, 0x27, 0xc4, 0x0c, 0x65, 0xdb, 0xbf, 0x1a, 0x73, 0x1b, 0x66, 0x1b, 0xb5, - 0x27, 0x51, 0xe8, 0x45, 0x2a, 0xfd, 0x57, 0xc3, 0x56, 0x21, 0xdf, 0xa8, 0xc9, 0x93, 0x3e, 0x0c, - 0x75, 0x0b, 0x72, 0x8d, 0xda, 0xc1, 0x29, 0xf6, 0x86, 0x81, 0xd6, 0x61, 0x3e, 0x06, 0x55, 0x1d, - 0x4c, 0xdd, 0x61, 0xc8, 0x12, 0x5c, 0x6f, 0xd4, 0x9e, 0x32, 0x8b, 0x38, 0xa4, 0x25, 0x4a, 0x3b, - 0x0a, 0x7f, 0x0f, 0x16, 0x1a, 0xb5, 0xdd, 0x18, 0xcd, 0xfd, 0x43, 0x71, 0x81, 0x86, 0xa0, 0xcb, - 0xb0, 0xd8, 0xa8, 0xf5, 0xee, 0xf7, 0x2e, 0xf1, 0x69, 0x47, 0xfe, 0x04, 0x18, 0x12, 0x53, 0xf9, - 0x3e, 0xf5, 0xe3, 0xd9, 0xb2, 0xf6, 0xf2, 0x6c, 0x59, 0xfb, 0xf9, 0x6c, 0x59, 0x7b, 0xf1, 0x7a, - 0x79, 0xe2, 0xe5, 0xeb, 0xe5, 0x89, 0x57, 0xaf, 0x97, 0x27, 0xe0, 0xa6, 0xc9, 0xdd, 0xe1, 0x27, - 0xa6, 0x92, 0xab, 0xca, 0x89, 0xba, 0xf8, 0xf5, 0x5d, 0xd7, 0x1a, 0x9f, 0xb6, 0x68, 0x68, 0x47, - 0xc7, 0x25, 0x93, 0xbb, 0x1b, 0x26, 0x0f, 0x5c, 0x1e, 0x6c, 0xf8, 0xc4, 0xc1, 0x5d, 0xe2, 0x6f, - 0x74, 0xca, 0xbd, 0xa1, 0x69, 0x63, 0xca, 0x82, 0x8d, 0xa1, 0xbf, 0xeb, 0xdf, 0x8f, 0xed, 0xc4, - 0xfc, 0x26, 0x95, 0xae, 0x57, 0xab, 0xdf, 0xa5, 0x96, 0xea, 0x89, 0x9c, 0xaa, 0x90, 0x13, 0xaf, - 0x5e, 0x3a, 0x54, 0xa8, 0x9f, 0xce, 0xfd, 0x47, 0xc2, 0x7f, 0x14, 0xfb, 0x8f, 0x12, 0xff, 0x59, - 0xea, 0xce, 0x50, 0xff, 0xd1, 0xc3, 0x7a, 0x25, 0x69, 0xe5, 0xbf, 0xa5, 0x56, 0x12, 0xec, 0xf6, - 0xb6, 0x00, 0x6f, 0x6f, 0xc7, 0xe8, 0xed, 0xed, 0x04, 0x7e, 0x3c, 0x2d, 0xff, 0x75, 0xd8, 0xfa, - 0x33, 0x00, 0x00, 0xff, 0xff, 0x88, 0xb9, 0x8c, 0xd5, 0xa3, 0x10, 0x00, 0x00, -} - -func (m *Fee) 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 *Fee) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Fee) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.AssetId != nil { - { - size, err := m.AssetId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Amount != nil { - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Address) 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 *Address) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Address) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.AltBech32M) > 0 { - i -= len(m.AltBech32M) - copy(dAtA[i:], m.AltBech32M) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.AltBech32M))) - i-- - dAtA[i] = 0x12 - } - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *AddressView) 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 *AddressView) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AddressView) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.AddressView != nil { - { - size := m.AddressView.Size() - i -= size - if _, err := m.AddressView.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *AddressView_Visible_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AddressView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Visible != nil { - { - size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *AddressView_Opaque_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AddressView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Opaque != nil { - { - size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *AddressView_Visible) 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 *AddressView_Visible) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AddressView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Index != nil { - { - size, err := m.Index.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Address != nil { - { - size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *AddressView_Opaque) 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 *AddressView_Opaque) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AddressView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Address != nil { - { - size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SpendKey) 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 *SpendKey) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SpendKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SpendVerificationKey) 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 *SpendVerificationKey) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SpendVerificationKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *FullViewingKey) 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 *FullViewingKey) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *FullViewingKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *AccountGroupId) 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 *AccountGroupId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Diversifier) 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 *Diversifier) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Diversifier) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *AddressIndex) 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 *AddressIndex) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AddressIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Randomizer) > 0 { - i -= len(m.Randomizer) - copy(dAtA[i:], m.Randomizer) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Randomizer))) - i-- - dAtA[i] = 0x1a - } - if m.Account != 0 { - i = encodeVarintCrypto(dAtA, i, uint64(m.Account)) - i-- - dAtA[i] = 0x10 - } - return len(dAtA) - i, nil -} - -func (m *StateCommitment) 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 *StateCommitment) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StateCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *BalanceCommitment) 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 *BalanceCommitment) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *BalanceCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *AssetId) 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 *AssetId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AssetId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.AltBaseDenom) > 0 { - i -= len(m.AltBaseDenom) - copy(dAtA[i:], m.AltBaseDenom) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.AltBaseDenom))) - i-- - dAtA[i] = 0x1a - } - if len(m.AltBech32M) > 0 { - i -= len(m.AltBech32M) - copy(dAtA[i:], m.AltBech32M) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.AltBech32M))) - i-- - dAtA[i] = 0x12 - } - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Amount) 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 *Amount) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Amount) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Hi != 0 { - i = encodeVarintCrypto(dAtA, i, uint64(m.Hi)) - i-- - dAtA[i] = 0x10 - } - if m.Lo != 0 { - i = encodeVarintCrypto(dAtA, i, uint64(m.Lo)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *Denom) 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 *Denom) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Denom) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Denom) > 0 { - i -= len(m.Denom) - copy(dAtA[i:], m.Denom) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Denom))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *DenomMetadata) 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 *DenomMetadata) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DenomMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.PenumbraAssetId != nil { - { - size, err := m.PenumbraAssetId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x7c - i-- - dAtA[i] = 0x82 - } - if len(m.UriHash) > 0 { - i -= len(m.UriHash) - copy(dAtA[i:], m.UriHash) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.UriHash))) - i-- - dAtA[i] = 0x42 - } - if len(m.Uri) > 0 { - i -= len(m.Uri) - copy(dAtA[i:], m.Uri) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Uri))) - i-- - dAtA[i] = 0x3a - } - if len(m.Symbol) > 0 { - i -= len(m.Symbol) - copy(dAtA[i:], m.Symbol) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Symbol))) - i-- - dAtA[i] = 0x32 - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0x2a - } - if len(m.Display) > 0 { - i -= len(m.Display) - copy(dAtA[i:], m.Display) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Display))) - i-- - dAtA[i] = 0x22 - } - if len(m.Base) > 0 { - i -= len(m.Base) - copy(dAtA[i:], m.Base) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Base))) - i-- - dAtA[i] = 0x1a - } - if len(m.DenomUnits) > 0 { - for iNdEx := len(m.DenomUnits) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.DenomUnits[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if len(m.Description) > 0 { - i -= len(m.Description) - copy(dAtA[i:], m.Description) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Description))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *DenomUnit) 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 *DenomUnit) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DenomUnit) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Aliases) > 0 { - for iNdEx := len(m.Aliases) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Aliases[iNdEx]) - copy(dAtA[i:], m.Aliases[iNdEx]) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Aliases[iNdEx]))) - i-- - dAtA[i] = 0x1a - } - } - if m.Exponent != 0 { - i = encodeVarintCrypto(dAtA, i, uint64(m.Exponent)) - i-- - dAtA[i] = 0x10 - } - if len(m.Denom) > 0 { - i -= len(m.Denom) - copy(dAtA[i:], m.Denom) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Denom))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Value) 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 *Value) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Value) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.AssetId != nil { - { - size, err := m.AssetId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Amount != nil { - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ValueView) 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 *ValueView) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ValueView) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.ValueView != nil { - { - size := m.ValueView.Size() - i -= size - if _, err := m.ValueView.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *ValueView_KnownDenom_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ValueView_KnownDenom_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.KnownDenom != nil { - { - size, err := m.KnownDenom.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *ValueView_UnknownDenom_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ValueView_UnknownDenom_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.UnknownDenom != nil { - { - size, err := m.UnknownDenom.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *ValueView_KnownDenom) 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 *ValueView_KnownDenom) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ValueView_KnownDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Denom != nil { - { - size, err := m.Denom.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Amount != nil { - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ValueView_UnknownDenom) 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 *ValueView_UnknownDenom) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ValueView_UnknownDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.AssetId != nil { - { - size, err := m.AssetId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Amount != nil { - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *MerkleRoot) 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 *MerkleRoot) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MerkleRoot) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *IdentityKey) 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 *IdentityKey) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *IdentityKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Ik) > 0 { - i -= len(m.Ik) - copy(dAtA[i:], m.Ik) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Ik))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *GovernanceKey) 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 *GovernanceKey) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GovernanceKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Gk) > 0 { - i -= len(m.Gk) - copy(dAtA[i:], m.Gk) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Gk))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ConsensusKey) 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 *ConsensusKey) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ConsensusKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Note) 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 *Note) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Note) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Address != nil { - { - size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if len(m.Rseed) > 0 { - i -= len(m.Rseed) - copy(dAtA[i:], m.Rseed) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Rseed))) - i-- - dAtA[i] = 0x12 - } - if m.Value != nil { - { - size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *NoteView) 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 *NoteView) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NoteView) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Address != nil { - { - size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if len(m.Rseed) > 0 { - i -= len(m.Rseed) - copy(dAtA[i:], m.Rseed) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Rseed))) - i-- - dAtA[i] = 0x12 - } - if m.Value != nil { - { - size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *NoteCiphertext) 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 *NoteCiphertext) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NoteCiphertext) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Nullifier) 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 *Nullifier) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Nullifier) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SpendAuthSignature) 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 *SpendAuthSignature) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SpendAuthSignature) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *BindingSignature) 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 *BindingSignature) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *BindingSignature) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *NotePayload) 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 *NotePayload) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotePayload) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.EncryptedNote != nil { - { - size, err := m.EncryptedNote.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if len(m.EphemeralKey) > 0 { - i -= len(m.EphemeralKey) - copy(dAtA[i:], m.EphemeralKey) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.EphemeralKey))) - i-- - dAtA[i] = 0x12 - } - if m.NoteCommitment != nil { - { - size, err := m.NoteCommitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *StateCommitmentProof) 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 *StateCommitmentProof) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StateCommitmentProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.AuthPath) > 0 { - for iNdEx := len(m.AuthPath) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.AuthPath[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - } - if m.Position != 0 { - i = encodeVarintCrypto(dAtA, i, uint64(m.Position)) - i-- - dAtA[i] = 0x10 - } - if m.NoteCommitment != nil { - { - size, err := m.NoteCommitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCrypto(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *MerklePathChunk) 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 *MerklePathChunk) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MerklePathChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Sibling_3) > 0 { - i -= len(m.Sibling_3) - copy(dAtA[i:], m.Sibling_3) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Sibling_3))) - i-- - dAtA[i] = 0x1a - } - if len(m.Sibling_2) > 0 { - i -= len(m.Sibling_2) - copy(dAtA[i:], m.Sibling_2) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Sibling_2))) - i-- - dAtA[i] = 0x12 - } - if len(m.Sibling_1) > 0 { - i -= len(m.Sibling_1) - copy(dAtA[i:], m.Sibling_1) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Sibling_1))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Clue) 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 *Clue) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Clue) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *EffectHash) 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 *EffectHash) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *EffectHash) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ZKOutputProof) 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 *ZKOutputProof) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ZKOutputProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ZKSpendProof) 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 *ZKSpendProof) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ZKSpendProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ZKSwapProof) 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 *ZKSwapProof) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ZKSwapProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ZKSwapClaimProof) 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 *ZKSwapClaimProof) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ZKSwapClaimProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ZKUndelegateClaimProof) 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 *ZKUndelegateClaimProof) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ZKUndelegateClaimProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ZKDelegatorVoteProof) 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 *ZKDelegatorVoteProof) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ZKDelegatorVoteProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ZKNullifierDerivationProof) 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 *ZKNullifierDerivationProof) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ZKNullifierDerivationProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintCrypto(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func encodeVarintCrypto(dAtA []byte, offset int, v uint64) int { - offset -= sovCrypto(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *Fee) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Amount != nil { - l = m.Amount.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - if m.AssetId != nil { - l = m.AssetId.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *Address) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.AltBech32M) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *AddressView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AddressView != nil { - n += m.AddressView.Size() - } - return n -} - -func (m *AddressView_Visible_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Visible != nil { - l = m.Visible.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} -func (m *AddressView_Opaque_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Opaque != nil { - l = m.Opaque.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} -func (m *AddressView_Visible) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Address != nil { - l = m.Address.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - if m.Index != nil { - l = m.Index.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *AddressView_Opaque) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Address != nil { - l = m.Address.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *SpendKey) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *SpendVerificationKey) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *FullViewingKey) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *AccountGroupId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *Diversifier) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *AddressIndex) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Account != 0 { - n += 1 + sovCrypto(uint64(m.Account)) - } - l = len(m.Randomizer) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *StateCommitment) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *BalanceCommitment) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *AssetId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.AltBech32M) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.AltBaseDenom) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *Amount) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Lo != 0 { - n += 1 + sovCrypto(uint64(m.Lo)) - } - if m.Hi != 0 { - n += 1 + sovCrypto(uint64(m.Hi)) - } - return n -} - -func (m *Denom) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Denom) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *DenomMetadata) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Description) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - if len(m.DenomUnits) > 0 { - for _, e := range m.DenomUnits { - l = e.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - } - l = len(m.Base) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.Display) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.Name) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.Symbol) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.Uri) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.UriHash) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - if m.PenumbraAssetId != nil { - l = m.PenumbraAssetId.Size() - n += 2 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *DenomUnit) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Denom) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - if m.Exponent != 0 { - n += 1 + sovCrypto(uint64(m.Exponent)) - } - if len(m.Aliases) > 0 { - for _, s := range m.Aliases { - l = len(s) - n += 1 + l + sovCrypto(uint64(l)) - } - } - return n -} - -func (m *Value) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Amount != nil { - l = m.Amount.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - if m.AssetId != nil { - l = m.AssetId.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ValueView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ValueView != nil { - n += m.ValueView.Size() - } - return n -} - -func (m *ValueView_KnownDenom_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.KnownDenom != nil { - l = m.KnownDenom.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} -func (m *ValueView_UnknownDenom_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.UnknownDenom != nil { - l = m.UnknownDenom.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} -func (m *ValueView_KnownDenom) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Amount != nil { - l = m.Amount.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - if m.Denom != nil { - l = m.Denom.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ValueView_UnknownDenom) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Amount != nil { - l = m.Amount.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - if m.AssetId != nil { - l = m.AssetId.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *MerkleRoot) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *IdentityKey) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Ik) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *GovernanceKey) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Gk) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ConsensusKey) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *Note) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != nil { - l = m.Value.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.Rseed) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - if m.Address != nil { - l = m.Address.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *NoteView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != nil { - l = m.Value.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.Rseed) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - if m.Address != nil { - l = m.Address.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *NoteCiphertext) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *Nullifier) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *SpendAuthSignature) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *BindingSignature) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *NotePayload) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.NoteCommitment != nil { - l = m.NoteCommitment.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.EphemeralKey) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - if m.EncryptedNote != nil { - l = m.EncryptedNote.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *StateCommitmentProof) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.NoteCommitment != nil { - l = m.NoteCommitment.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - if m.Position != 0 { - n += 1 + sovCrypto(uint64(m.Position)) - } - if len(m.AuthPath) > 0 { - for _, e := range m.AuthPath { - l = e.Size() - n += 1 + l + sovCrypto(uint64(l)) - } - } - return n -} - -func (m *MerklePathChunk) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Sibling_1) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.Sibling_2) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - l = len(m.Sibling_3) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *Clue) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *EffectHash) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ZKOutputProof) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ZKSpendProof) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ZKSwapProof) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ZKSwapClaimProof) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ZKUndelegateClaimProof) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ZKDelegatorVoteProof) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func (m *ZKNullifierDerivationProof) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovCrypto(uint64(l)) - } - return n -} - -func sovCrypto(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozCrypto(x uint64) (n int) { - return sovCrypto(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *Fee) 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 ErrIntOverflowCrypto - } - 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: Fee: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Fee: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Amount == nil { - m.Amount = &Amount{} - } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.AssetId == nil { - m.AssetId = &AssetId{} - } - if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Address) 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 ErrIntOverflowCrypto - } - 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: Address: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Address: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AltBech32M", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.AltBech32M = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AddressView) 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 ErrIntOverflowCrypto - } - 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: AddressView: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AddressView: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &AddressView_Visible{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.AddressView = &AddressView_Visible_{v} - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &AddressView_Opaque{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.AddressView = &AddressView_Opaque_{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AddressView_Visible) 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 ErrIntOverflowCrypto - } - 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: Visible: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Address == nil { - m.Address = &Address{} - } - if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Index == nil { - m.Index = &AddressIndex{} - } - if err := m.Index.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.AccountGroupId == nil { - m.AccountGroupId = &AccountGroupId{} - } - if err := m.AccountGroupId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AddressView_Opaque) 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 ErrIntOverflowCrypto - } - 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: Opaque: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Address == nil { - m.Address = &Address{} - } - if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SpendKey) 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 ErrIntOverflowCrypto - } - 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: SpendKey: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SpendKey: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SpendVerificationKey) 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 ErrIntOverflowCrypto - } - 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: SpendVerificationKey: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SpendVerificationKey: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *FullViewingKey) 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 ErrIntOverflowCrypto - } - 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: FullViewingKey: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: FullViewingKey: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AccountGroupId) 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 ErrIntOverflowCrypto - } - 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: AccountGroupId: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AccountGroupId: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Diversifier) 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 ErrIntOverflowCrypto - } - 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: Diversifier: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Diversifier: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AddressIndex) 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 ErrIntOverflowCrypto - } - 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: AddressIndex: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AddressIndex: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType) - } - m.Account = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Account |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Randomizer", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Randomizer = append(m.Randomizer[:0], dAtA[iNdEx:postIndex]...) - if m.Randomizer == nil { - m.Randomizer = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StateCommitment) 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 ErrIntOverflowCrypto - } - 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: StateCommitment: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StateCommitment: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *BalanceCommitment) 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 ErrIntOverflowCrypto - } - 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: BalanceCommitment: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: BalanceCommitment: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AssetId) 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 ErrIntOverflowCrypto - } - 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: AssetId: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AssetId: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AltBech32M", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.AltBech32M = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AltBaseDenom", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.AltBaseDenom = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Amount) 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 ErrIntOverflowCrypto - } - 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: Amount: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Amount: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Lo", wireType) - } - m.Lo = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Lo |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Hi", wireType) - } - m.Hi = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Hi |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Denom) 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 ErrIntOverflowCrypto - } - 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: Denom: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Denom: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Denom = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DenomMetadata) 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 ErrIntOverflowCrypto - } - 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: DenomMetadata: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DenomMetadata: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Description = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DenomUnits", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.DenomUnits = append(m.DenomUnits, &DenomUnit{}) - if err := m.DenomUnits[len(m.DenomUnits)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Base = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Display", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Display = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Symbol = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Uri", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Uri = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UriHash", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.UriHash = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 1984: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PenumbraAssetId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.PenumbraAssetId == nil { - m.PenumbraAssetId = &AssetId{} - } - if err := m.PenumbraAssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DenomUnit) 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 ErrIntOverflowCrypto - } - 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: DenomUnit: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DenomUnit: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Denom = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Exponent", wireType) - } - m.Exponent = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Exponent |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Aliases", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - 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 ErrInvalidLengthCrypto - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Aliases = append(m.Aliases, string(dAtA[iNdEx:postIndex])) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Value) 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 ErrIntOverflowCrypto - } - 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: Value: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Value: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Amount == nil { - m.Amount = &Amount{} - } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.AssetId == nil { - m.AssetId = &AssetId{} - } - if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ValueView) 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 ErrIntOverflowCrypto - } - 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: ValueView: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ValueView: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KnownDenom", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ValueView_KnownDenom{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.ValueView = &ValueView_KnownDenom_{v} - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UnknownDenom", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ValueView_UnknownDenom{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.ValueView = &ValueView_UnknownDenom_{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ValueView_KnownDenom) 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 ErrIntOverflowCrypto - } - 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: KnownDenom: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: KnownDenom: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Amount == nil { - m.Amount = &Amount{} - } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Denom == nil { - m.Denom = &DenomMetadata{} - } - if err := m.Denom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ValueView_UnknownDenom) 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 ErrIntOverflowCrypto - } - 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: UnknownDenom: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: UnknownDenom: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Amount == nil { - m.Amount = &Amount{} - } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.AssetId == nil { - m.AssetId = &AssetId{} - } - if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MerkleRoot) 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 ErrIntOverflowCrypto - } - 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: MerkleRoot: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MerkleRoot: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *IdentityKey) 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 ErrIntOverflowCrypto - } - 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: IdentityKey: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: IdentityKey: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ik", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Ik = append(m.Ik[:0], dAtA[iNdEx:postIndex]...) - if m.Ik == nil { - m.Ik = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *GovernanceKey) 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 ErrIntOverflowCrypto - } - 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: GovernanceKey: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GovernanceKey: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Gk", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Gk = append(m.Gk[:0], dAtA[iNdEx:postIndex]...) - if m.Gk == nil { - m.Gk = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ConsensusKey) 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 ErrIntOverflowCrypto - } - 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: ConsensusKey: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ConsensusKey: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Note) 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 ErrIntOverflowCrypto - } - 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: Note: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Note: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Value == nil { - m.Value = &Value{} - } - if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) - if m.Rseed == nil { - m.Rseed = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Address == nil { - m.Address = &Address{} - } - if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *NoteView) 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 ErrIntOverflowCrypto - } - 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: NoteView: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: NoteView: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Value == nil { - m.Value = &ValueView{} - } - if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) - if m.Rseed == nil { - m.Rseed = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Address == nil { - m.Address = &AddressView{} - } - if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *NoteCiphertext) 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 ErrIntOverflowCrypto - } - 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: NoteCiphertext: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: NoteCiphertext: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Nullifier) 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 ErrIntOverflowCrypto - } - 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: Nullifier: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Nullifier: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SpendAuthSignature) 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 ErrIntOverflowCrypto - } - 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: SpendAuthSignature: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SpendAuthSignature: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *BindingSignature) 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 ErrIntOverflowCrypto - } - 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: BindingSignature: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: BindingSignature: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *NotePayload) 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 ErrIntOverflowCrypto - } - 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: NotePayload: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: NotePayload: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NoteCommitment", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.NoteCommitment == nil { - m.NoteCommitment = &StateCommitment{} - } - if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EphemeralKey", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.EphemeralKey = append(m.EphemeralKey[:0], dAtA[iNdEx:postIndex]...) - if m.EphemeralKey == nil { - m.EphemeralKey = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EncryptedNote", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.EncryptedNote == nil { - m.EncryptedNote = &NoteCiphertext{} - } - if err := m.EncryptedNote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StateCommitmentProof) 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 ErrIntOverflowCrypto - } - 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: StateCommitmentProof: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StateCommitmentProof: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NoteCommitment", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.NoteCommitment == nil { - m.NoteCommitment = &StateCommitment{} - } - if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) - } - m.Position = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Position |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AuthPath", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.AuthPath = append(m.AuthPath, &MerklePathChunk{}) - if err := m.AuthPath[len(m.AuthPath)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MerklePathChunk) 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 ErrIntOverflowCrypto - } - 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: MerklePathChunk: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MerklePathChunk: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sibling_1", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Sibling_1 = append(m.Sibling_1[:0], dAtA[iNdEx:postIndex]...) - if m.Sibling_1 == nil { - m.Sibling_1 = []byte{} - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sibling_2", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Sibling_2 = append(m.Sibling_2[:0], dAtA[iNdEx:postIndex]...) - if m.Sibling_2 == nil { - m.Sibling_2 = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sibling_3", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Sibling_3 = append(m.Sibling_3[:0], dAtA[iNdEx:postIndex]...) - if m.Sibling_3 == nil { - m.Sibling_3 = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Clue) 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 ErrIntOverflowCrypto - } - 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: Clue: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Clue: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *EffectHash) 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 ErrIntOverflowCrypto - } - 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: EffectHash: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: EffectHash: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ZKOutputProof) 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 ErrIntOverflowCrypto - } - 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: ZKOutputProof: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ZKOutputProof: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ZKSpendProof) 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 ErrIntOverflowCrypto - } - 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: ZKSpendProof: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ZKSpendProof: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ZKSwapProof) 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 ErrIntOverflowCrypto - } - 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: ZKSwapProof: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ZKSwapProof: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ZKSwapClaimProof) 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 ErrIntOverflowCrypto - } - 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: ZKSwapClaimProof: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ZKSwapClaimProof: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ZKUndelegateClaimProof) 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 ErrIntOverflowCrypto - } - 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: ZKUndelegateClaimProof: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ZKUndelegateClaimProof: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ZKDelegatorVoteProof) 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 ErrIntOverflowCrypto - } - 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: ZKDelegatorVoteProof: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ZKDelegatorVoteProof: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ZKNullifierDerivationProof) 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 ErrIntOverflowCrypto - } - 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: ZKNullifierDerivationProof: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ZKNullifierDerivationProof: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCrypto - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthCrypto - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthCrypto - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipCrypto(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthCrypto - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipCrypto(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, ErrIntOverflowCrypto - } - 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, ErrIntOverflowCrypto - } - 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, ErrIntOverflowCrypto - } - 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, ErrInvalidLengthCrypto - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupCrypto - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthCrypto - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthCrypto = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowCrypto = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupCrypto = fmt.Errorf("proto: unexpected end of group") -) diff --git a/relayer/chains/penumbra/core/dex/v1alpha1/dex.pb.go b/relayer/chains/penumbra/core/dex/v1alpha1/dex.pb.go deleted file mode 100644 index 9456bbbb2..000000000 --- a/relayer/chains/penumbra/core/dex/v1alpha1/dex.pb.go +++ /dev/null @@ -1,9422 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: penumbra/core/dex/v1alpha1/dex.proto - -package dexv1alpha1 - -import ( - fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" - v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" - 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 - -type PositionState_PositionStateEnum int32 - -const ( - PositionState_POSITION_STATE_ENUM_UNSPECIFIED PositionState_PositionStateEnum = 0 - // The position has been opened, is active, has reserves and accumulated - // fees, and can be traded against. - PositionState_POSITION_STATE_ENUM_OPENED PositionState_PositionStateEnum = 1 - // The position has been closed, is inactive and can no longer be traded - // against, but still has reserves and accumulated fees. - PositionState_POSITION_STATE_ENUM_CLOSED PositionState_PositionStateEnum = 2 - // The final reserves and accumulated fees have been withdrawn, leaving an - // empty, inactive position awaiting (possible) retroactive rewards. - PositionState_POSITION_STATE_ENUM_WITHDRAWN PositionState_PositionStateEnum = 3 - // Any retroactive rewards have been claimed. The position is now an inert, - // historical artefact. - PositionState_POSITION_STATE_ENUM_CLAIMED PositionState_PositionStateEnum = 4 -) - -var PositionState_PositionStateEnum_name = map[int32]string{ - 0: "POSITION_STATE_ENUM_UNSPECIFIED", - 1: "POSITION_STATE_ENUM_OPENED", - 2: "POSITION_STATE_ENUM_CLOSED", - 3: "POSITION_STATE_ENUM_WITHDRAWN", - 4: "POSITION_STATE_ENUM_CLAIMED", -} - -var PositionState_PositionStateEnum_value = map[string]int32{ - "POSITION_STATE_ENUM_UNSPECIFIED": 0, - "POSITION_STATE_ENUM_OPENED": 1, - "POSITION_STATE_ENUM_CLOSED": 2, - "POSITION_STATE_ENUM_WITHDRAWN": 3, - "POSITION_STATE_ENUM_CLAIMED": 4, -} - -func (x PositionState_PositionStateEnum) String() string { - return proto.EnumName(PositionState_PositionStateEnum_name, int32(x)) -} - -func (PositionState_PositionStateEnum) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{18, 0} -} - -// A transaction action that submits a swap to the dex. -type Swap struct { - // Contains the Swap proof. - Proof *v1alpha1.ZKSwapProof `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"` - // Encapsulates the authorized fields of the Swap action, used in signing. - Body *SwapBody `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"` -} - -func (m *Swap) Reset() { *m = Swap{} } -func (m *Swap) String() string { return proto.CompactTextString(m) } -func (*Swap) ProtoMessage() {} -func (*Swap) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{0} -} -func (m *Swap) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Swap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Swap.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 *Swap) XXX_Merge(src proto.Message) { - xxx_messageInfo_Swap.Merge(m, src) -} -func (m *Swap) XXX_Size() int { - return m.Size() -} -func (m *Swap) XXX_DiscardUnknown() { - xxx_messageInfo_Swap.DiscardUnknown(m) -} - -var xxx_messageInfo_Swap proto.InternalMessageInfo - -func (m *Swap) GetProof() *v1alpha1.ZKSwapProof { - if m != nil { - return m.Proof - } - return nil -} - -func (m *Swap) GetBody() *SwapBody { - if m != nil { - return m.Body - } - return nil -} - -// A transaction action that obtains assets previously confirmed -// via a Swap transaction. Does not include a spend authorization -// signature, as it is only capable of consuming the NFT from a -// Swap transaction. -type SwapClaim struct { - // Contains the SwapClaim proof. - Proof []byte `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"` - // Encapsulates the authorized fields of the SwapClaim action, used in signing. - Body *SwapClaimBody `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` - // The epoch duration of the chain when the swap claim took place. - EpochDuration uint64 `protobuf:"varint,7,opt,name=epoch_duration,json=epochDuration,proto3" json:"epoch_duration,omitempty"` -} - -func (m *SwapClaim) Reset() { *m = SwapClaim{} } -func (m *SwapClaim) String() string { return proto.CompactTextString(m) } -func (*SwapClaim) ProtoMessage() {} -func (*SwapClaim) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{1} -} -func (m *SwapClaim) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapClaim.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 *SwapClaim) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapClaim.Merge(m, src) -} -func (m *SwapClaim) XXX_Size() int { - return m.Size() -} -func (m *SwapClaim) XXX_DiscardUnknown() { - xxx_messageInfo_SwapClaim.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapClaim proto.InternalMessageInfo - -func (m *SwapClaim) GetProof() []byte { - if m != nil { - return m.Proof - } - return nil -} - -func (m *SwapClaim) GetBody() *SwapClaimBody { - if m != nil { - return m.Body - } - return nil -} - -func (m *SwapClaim) GetEpochDuration() uint64 { - if m != nil { - return m.EpochDuration - } - return 0 -} - -// Encapsulates the authorized fields of the SwapClaim action, used in signing. -type SwapClaimBody struct { - // The nullifier for the Swap commitment to be consumed. - Nullifier *v1alpha1.Nullifier `protobuf:"bytes,1,opt,name=nullifier,proto3" json:"nullifier,omitempty"` - // The fee allows `SwapClaim` without an additional `Spend`. - Fee *v1alpha1.Fee `protobuf:"bytes,2,opt,name=fee,proto3" json:"fee,omitempty"` - // Note output for asset 1. - Output_1Commitment *v1alpha1.StateCommitment `protobuf:"bytes,3,opt,name=output_1_commitment,json=output1Commitment,proto3" json:"output_1_commitment,omitempty"` - // Note output for asset 2. - Output_2Commitment *v1alpha1.StateCommitment `protobuf:"bytes,4,opt,name=output_2_commitment,json=output2Commitment,proto3" json:"output_2_commitment,omitempty"` - // Input and output amounts, and asset IDs for the assets in the swap. - OutputData *BatchSwapOutputData `protobuf:"bytes,6,opt,name=output_data,json=outputData,proto3" json:"output_data,omitempty"` -} - -func (m *SwapClaimBody) Reset() { *m = SwapClaimBody{} } -func (m *SwapClaimBody) String() string { return proto.CompactTextString(m) } -func (*SwapClaimBody) ProtoMessage() {} -func (*SwapClaimBody) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{2} -} -func (m *SwapClaimBody) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapClaimBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapClaimBody.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 *SwapClaimBody) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapClaimBody.Merge(m, src) -} -func (m *SwapClaimBody) XXX_Size() int { - return m.Size() -} -func (m *SwapClaimBody) XXX_DiscardUnknown() { - xxx_messageInfo_SwapClaimBody.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapClaimBody proto.InternalMessageInfo - -func (m *SwapClaimBody) GetNullifier() *v1alpha1.Nullifier { - if m != nil { - return m.Nullifier - } - return nil -} - -func (m *SwapClaimBody) GetFee() *v1alpha1.Fee { - if m != nil { - return m.Fee - } - return nil -} - -func (m *SwapClaimBody) GetOutput_1Commitment() *v1alpha1.StateCommitment { - if m != nil { - return m.Output_1Commitment - } - return nil -} - -func (m *SwapClaimBody) GetOutput_2Commitment() *v1alpha1.StateCommitment { - if m != nil { - return m.Output_2Commitment - } - return nil -} - -func (m *SwapClaimBody) GetOutputData() *BatchSwapOutputData { - if m != nil { - return m.OutputData - } - return nil -} - -// The authorized data of a Swap transaction. -type SwapBody struct { - // The trading pair to swap. - TradingPair *TradingPair `protobuf:"bytes,1,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` - // The amount for asset 1. - Delta_1I *v1alpha1.Amount `protobuf:"bytes,2,opt,name=delta_1_i,json=delta1I,proto3" json:"delta_1_i,omitempty"` - // The amount for asset 2. - Delta_2I *v1alpha1.Amount `protobuf:"bytes,3,opt,name=delta_2_i,json=delta2I,proto3" json:"delta_2_i,omitempty"` - // A commitment to a prepaid fee for the future SwapClaim. - // This is recorded separately from delta_j_i because it's shielded; - // in the future we'll want separate commitments to each delta_j_i - // anyways in order to prove consistency with flow encryption. - FeeCommitment *v1alpha1.BalanceCommitment `protobuf:"bytes,4,opt,name=fee_commitment,json=feeCommitment,proto3" json:"fee_commitment,omitempty"` - // The swap commitment and encryption of the swap data. - Payload *SwapPayload `protobuf:"bytes,5,opt,name=payload,proto3" json:"payload,omitempty"` -} - -func (m *SwapBody) Reset() { *m = SwapBody{} } -func (m *SwapBody) String() string { return proto.CompactTextString(m) } -func (*SwapBody) ProtoMessage() {} -func (*SwapBody) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{3} -} -func (m *SwapBody) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapBody.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 *SwapBody) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapBody.Merge(m, src) -} -func (m *SwapBody) XXX_Size() int { - return m.Size() -} -func (m *SwapBody) XXX_DiscardUnknown() { - xxx_messageInfo_SwapBody.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapBody proto.InternalMessageInfo - -func (m *SwapBody) GetTradingPair() *TradingPair { - if m != nil { - return m.TradingPair - } - return nil -} - -func (m *SwapBody) GetDelta_1I() *v1alpha1.Amount { - if m != nil { - return m.Delta_1I - } - return nil -} - -func (m *SwapBody) GetDelta_2I() *v1alpha1.Amount { - if m != nil { - return m.Delta_2I - } - return nil -} - -func (m *SwapBody) GetFeeCommitment() *v1alpha1.BalanceCommitment { - if m != nil { - return m.FeeCommitment - } - return nil -} - -func (m *SwapBody) GetPayload() *SwapPayload { - if m != nil { - return m.Payload - } - return nil -} - -type SwapPayload struct { - Commitment *v1alpha1.StateCommitment `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"` - EncryptedSwap []byte `protobuf:"bytes,2,opt,name=encrypted_swap,json=encryptedSwap,proto3" json:"encrypted_swap,omitempty"` -} - -func (m *SwapPayload) Reset() { *m = SwapPayload{} } -func (m *SwapPayload) String() string { return proto.CompactTextString(m) } -func (*SwapPayload) ProtoMessage() {} -func (*SwapPayload) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{4} -} -func (m *SwapPayload) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapPayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapPayload.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 *SwapPayload) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapPayload.Merge(m, src) -} -func (m *SwapPayload) XXX_Size() int { - return m.Size() -} -func (m *SwapPayload) XXX_DiscardUnknown() { - xxx_messageInfo_SwapPayload.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapPayload proto.InternalMessageInfo - -func (m *SwapPayload) GetCommitment() *v1alpha1.StateCommitment { - if m != nil { - return m.Commitment - } - return nil -} - -func (m *SwapPayload) GetEncryptedSwap() []byte { - if m != nil { - return m.EncryptedSwap - } - return nil -} - -type SwapPlaintext struct { - // The trading pair to swap. - TradingPair *TradingPair `protobuf:"bytes,1,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` - // Input amount of asset 1 - Delta_1I *v1alpha1.Amount `protobuf:"bytes,2,opt,name=delta_1_i,json=delta1I,proto3" json:"delta_1_i,omitempty"` - // Input amount of asset 2 - Delta_2I *v1alpha1.Amount `protobuf:"bytes,3,opt,name=delta_2_i,json=delta2I,proto3" json:"delta_2_i,omitempty"` - // Pre-paid fee to claim the swap - ClaimFee *v1alpha1.Fee `protobuf:"bytes,4,opt,name=claim_fee,json=claimFee,proto3" json:"claim_fee,omitempty"` - // Address that will claim the swap outputs via SwapClaim. - ClaimAddress *v1alpha1.Address `protobuf:"bytes,5,opt,name=claim_address,json=claimAddress,proto3" json:"claim_address,omitempty"` - // Swap rseed (blinding factors are derived from this) - Rseed []byte `protobuf:"bytes,6,opt,name=rseed,proto3" json:"rseed,omitempty"` -} - -func (m *SwapPlaintext) Reset() { *m = SwapPlaintext{} } -func (m *SwapPlaintext) String() string { return proto.CompactTextString(m) } -func (*SwapPlaintext) ProtoMessage() {} -func (*SwapPlaintext) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{5} -} -func (m *SwapPlaintext) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapPlaintext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapPlaintext.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 *SwapPlaintext) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapPlaintext.Merge(m, src) -} -func (m *SwapPlaintext) XXX_Size() int { - return m.Size() -} -func (m *SwapPlaintext) XXX_DiscardUnknown() { - xxx_messageInfo_SwapPlaintext.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapPlaintext proto.InternalMessageInfo - -func (m *SwapPlaintext) GetTradingPair() *TradingPair { - if m != nil { - return m.TradingPair - } - return nil -} - -func (m *SwapPlaintext) GetDelta_1I() *v1alpha1.Amount { - if m != nil { - return m.Delta_1I - } - return nil -} - -func (m *SwapPlaintext) GetDelta_2I() *v1alpha1.Amount { - if m != nil { - return m.Delta_2I - } - return nil -} - -func (m *SwapPlaintext) GetClaimFee() *v1alpha1.Fee { - if m != nil { - return m.ClaimFee - } - return nil -} - -func (m *SwapPlaintext) GetClaimAddress() *v1alpha1.Address { - if m != nil { - return m.ClaimAddress - } - return nil -} - -func (m *SwapPlaintext) GetRseed() []byte { - if m != nil { - return m.Rseed - } - return nil -} - -type SwapPlan struct { - // The plaintext version of the swap to be performed. - SwapPlaintext *SwapPlaintext `protobuf:"bytes,1,opt,name=swap_plaintext,json=swapPlaintext,proto3" json:"swap_plaintext,omitempty"` - // The blinding factor for the fee commitment. The fee in the SwapPlan is private to prevent linkability with the SwapClaim. - FeeBlinding []byte `protobuf:"bytes,2,opt,name=fee_blinding,json=feeBlinding,proto3" json:"fee_blinding,omitempty"` - // The first blinding factor to use for the ZK swap proof. - ProofBlindingR []byte `protobuf:"bytes,3,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` - // The second blinding factor to use for the ZK swap proof. - ProofBlindingS []byte `protobuf:"bytes,4,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` -} - -func (m *SwapPlan) Reset() { *m = SwapPlan{} } -func (m *SwapPlan) String() string { return proto.CompactTextString(m) } -func (*SwapPlan) ProtoMessage() {} -func (*SwapPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{6} -} -func (m *SwapPlan) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapPlan.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 *SwapPlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapPlan.Merge(m, src) -} -func (m *SwapPlan) XXX_Size() int { - return m.Size() -} -func (m *SwapPlan) XXX_DiscardUnknown() { - xxx_messageInfo_SwapPlan.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapPlan proto.InternalMessageInfo - -func (m *SwapPlan) GetSwapPlaintext() *SwapPlaintext { - if m != nil { - return m.SwapPlaintext - } - return nil -} - -func (m *SwapPlan) GetFeeBlinding() []byte { - if m != nil { - return m.FeeBlinding - } - return nil -} - -func (m *SwapPlan) GetProofBlindingR() []byte { - if m != nil { - return m.ProofBlindingR - } - return nil -} - -func (m *SwapPlan) GetProofBlindingS() []byte { - if m != nil { - return m.ProofBlindingS - } - return nil -} - -type SwapClaimPlan struct { - // The plaintext version of the swap to be performed. - SwapPlaintext *SwapPlaintext `protobuf:"bytes,1,opt,name=swap_plaintext,json=swapPlaintext,proto3" json:"swap_plaintext,omitempty"` - // The position of the swap commitment. - Position uint64 `protobuf:"varint,2,opt,name=position,proto3" json:"position,omitempty"` - // Input and output amounts for the Swap. - OutputData *BatchSwapOutputData `protobuf:"bytes,3,opt,name=output_data,json=outputData,proto3" json:"output_data,omitempty"` - // The epoch duration, used in proving. - EpochDuration uint64 `protobuf:"varint,4,opt,name=epoch_duration,json=epochDuration,proto3" json:"epoch_duration,omitempty"` - // The first blinding factor to use for the ZK swap claim proof. - ProofBlindingR []byte `protobuf:"bytes,5,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` - // The second blinding factor to use for the ZK swap claim proof. - ProofBlindingS []byte `protobuf:"bytes,6,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` -} - -func (m *SwapClaimPlan) Reset() { *m = SwapClaimPlan{} } -func (m *SwapClaimPlan) String() string { return proto.CompactTextString(m) } -func (*SwapClaimPlan) ProtoMessage() {} -func (*SwapClaimPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{7} -} -func (m *SwapClaimPlan) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapClaimPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapClaimPlan.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 *SwapClaimPlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapClaimPlan.Merge(m, src) -} -func (m *SwapClaimPlan) XXX_Size() int { - return m.Size() -} -func (m *SwapClaimPlan) XXX_DiscardUnknown() { - xxx_messageInfo_SwapClaimPlan.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapClaimPlan proto.InternalMessageInfo - -func (m *SwapClaimPlan) GetSwapPlaintext() *SwapPlaintext { - if m != nil { - return m.SwapPlaintext - } - return nil -} - -func (m *SwapClaimPlan) GetPosition() uint64 { - if m != nil { - return m.Position - } - return 0 -} - -func (m *SwapClaimPlan) GetOutputData() *BatchSwapOutputData { - if m != nil { - return m.OutputData - } - return nil -} - -func (m *SwapClaimPlan) GetEpochDuration() uint64 { - if m != nil { - return m.EpochDuration - } - return 0 -} - -func (m *SwapClaimPlan) GetProofBlindingR() []byte { - if m != nil { - return m.ProofBlindingR - } - return nil -} - -func (m *SwapClaimPlan) GetProofBlindingS() []byte { - if m != nil { - return m.ProofBlindingS - } - return nil -} - -type SwapView struct { - // Types that are valid to be assigned to SwapView: - // - // *SwapView_Visible_ - // *SwapView_Opaque_ - SwapView isSwapView_SwapView `protobuf_oneof:"swap_view"` -} - -func (m *SwapView) Reset() { *m = SwapView{} } -func (m *SwapView) String() string { return proto.CompactTextString(m) } -func (*SwapView) ProtoMessage() {} -func (*SwapView) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{8} -} -func (m *SwapView) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapView.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 *SwapView) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapView.Merge(m, src) -} -func (m *SwapView) XXX_Size() int { - return m.Size() -} -func (m *SwapView) XXX_DiscardUnknown() { - xxx_messageInfo_SwapView.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapView proto.InternalMessageInfo - -type isSwapView_SwapView interface { - isSwapView_SwapView() - MarshalTo([]byte) (int, error) - Size() int -} - -type SwapView_Visible_ struct { - Visible *SwapView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` -} -type SwapView_Opaque_ struct { - Opaque *SwapView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` -} - -func (*SwapView_Visible_) isSwapView_SwapView() {} -func (*SwapView_Opaque_) isSwapView_SwapView() {} - -func (m *SwapView) GetSwapView() isSwapView_SwapView { - if m != nil { - return m.SwapView - } - return nil -} - -func (m *SwapView) GetVisible() *SwapView_Visible { - if x, ok := m.GetSwapView().(*SwapView_Visible_); ok { - return x.Visible - } - return nil -} - -func (m *SwapView) GetOpaque() *SwapView_Opaque { - if x, ok := m.GetSwapView().(*SwapView_Opaque_); ok { - return x.Opaque - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*SwapView) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*SwapView_Visible_)(nil), - (*SwapView_Opaque_)(nil), - } -} - -type SwapView_Visible struct { - Swap *Swap `protobuf:"bytes,1,opt,name=swap,proto3" json:"swap,omitempty"` - SwapPlaintext *SwapPlaintext `protobuf:"bytes,3,opt,name=swap_plaintext,json=swapPlaintext,proto3" json:"swap_plaintext,omitempty"` -} - -func (m *SwapView_Visible) Reset() { *m = SwapView_Visible{} } -func (m *SwapView_Visible) String() string { return proto.CompactTextString(m) } -func (*SwapView_Visible) ProtoMessage() {} -func (*SwapView_Visible) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{8, 0} -} -func (m *SwapView_Visible) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapView_Visible.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 *SwapView_Visible) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapView_Visible.Merge(m, src) -} -func (m *SwapView_Visible) XXX_Size() int { - return m.Size() -} -func (m *SwapView_Visible) XXX_DiscardUnknown() { - xxx_messageInfo_SwapView_Visible.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapView_Visible proto.InternalMessageInfo - -func (m *SwapView_Visible) GetSwap() *Swap { - if m != nil { - return m.Swap - } - return nil -} - -func (m *SwapView_Visible) GetSwapPlaintext() *SwapPlaintext { - if m != nil { - return m.SwapPlaintext - } - return nil -} - -type SwapView_Opaque struct { - Swap *Swap `protobuf:"bytes,1,opt,name=swap,proto3" json:"swap,omitempty"` -} - -func (m *SwapView_Opaque) Reset() { *m = SwapView_Opaque{} } -func (m *SwapView_Opaque) String() string { return proto.CompactTextString(m) } -func (*SwapView_Opaque) ProtoMessage() {} -func (*SwapView_Opaque) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{8, 1} -} -func (m *SwapView_Opaque) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapView_Opaque.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 *SwapView_Opaque) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapView_Opaque.Merge(m, src) -} -func (m *SwapView_Opaque) XXX_Size() int { - return m.Size() -} -func (m *SwapView_Opaque) XXX_DiscardUnknown() { - xxx_messageInfo_SwapView_Opaque.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapView_Opaque proto.InternalMessageInfo - -func (m *SwapView_Opaque) GetSwap() *Swap { - if m != nil { - return m.Swap - } - return nil -} - -type SwapClaimView struct { - // Types that are valid to be assigned to SwapClaimView: - // - // *SwapClaimView_Visible_ - // *SwapClaimView_Opaque_ - SwapClaimView isSwapClaimView_SwapClaimView `protobuf_oneof:"swap_claim_view"` -} - -func (m *SwapClaimView) Reset() { *m = SwapClaimView{} } -func (m *SwapClaimView) String() string { return proto.CompactTextString(m) } -func (*SwapClaimView) ProtoMessage() {} -func (*SwapClaimView) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{9} -} -func (m *SwapClaimView) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapClaimView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapClaimView.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 *SwapClaimView) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapClaimView.Merge(m, src) -} -func (m *SwapClaimView) XXX_Size() int { - return m.Size() -} -func (m *SwapClaimView) XXX_DiscardUnknown() { - xxx_messageInfo_SwapClaimView.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapClaimView proto.InternalMessageInfo - -type isSwapClaimView_SwapClaimView interface { - isSwapClaimView_SwapClaimView() - MarshalTo([]byte) (int, error) - Size() int -} - -type SwapClaimView_Visible_ struct { - Visible *SwapClaimView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` -} -type SwapClaimView_Opaque_ struct { - Opaque *SwapClaimView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` -} - -func (*SwapClaimView_Visible_) isSwapClaimView_SwapClaimView() {} -func (*SwapClaimView_Opaque_) isSwapClaimView_SwapClaimView() {} - -func (m *SwapClaimView) GetSwapClaimView() isSwapClaimView_SwapClaimView { - if m != nil { - return m.SwapClaimView - } - return nil -} - -func (m *SwapClaimView) GetVisible() *SwapClaimView_Visible { - if x, ok := m.GetSwapClaimView().(*SwapClaimView_Visible_); ok { - return x.Visible - } - return nil -} - -func (m *SwapClaimView) GetOpaque() *SwapClaimView_Opaque { - if x, ok := m.GetSwapClaimView().(*SwapClaimView_Opaque_); ok { - return x.Opaque - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*SwapClaimView) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*SwapClaimView_Visible_)(nil), - (*SwapClaimView_Opaque_)(nil), - } -} - -type SwapClaimView_Visible struct { - SwapClaim *SwapClaim `protobuf:"bytes,1,opt,name=swap_claim,json=swapClaim,proto3" json:"swap_claim,omitempty"` - Output_1 *v1alpha1.NoteView `protobuf:"bytes,2,opt,name=output_1,json=output1,proto3" json:"output_1,omitempty"` - Output_2 *v1alpha1.NoteView `protobuf:"bytes,3,opt,name=output_2,json=output2,proto3" json:"output_2,omitempty"` -} - -func (m *SwapClaimView_Visible) Reset() { *m = SwapClaimView_Visible{} } -func (m *SwapClaimView_Visible) String() string { return proto.CompactTextString(m) } -func (*SwapClaimView_Visible) ProtoMessage() {} -func (*SwapClaimView_Visible) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{9, 0} -} -func (m *SwapClaimView_Visible) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapClaimView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapClaimView_Visible.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 *SwapClaimView_Visible) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapClaimView_Visible.Merge(m, src) -} -func (m *SwapClaimView_Visible) XXX_Size() int { - return m.Size() -} -func (m *SwapClaimView_Visible) XXX_DiscardUnknown() { - xxx_messageInfo_SwapClaimView_Visible.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapClaimView_Visible proto.InternalMessageInfo - -func (m *SwapClaimView_Visible) GetSwapClaim() *SwapClaim { - if m != nil { - return m.SwapClaim - } - return nil -} - -func (m *SwapClaimView_Visible) GetOutput_1() *v1alpha1.NoteView { - if m != nil { - return m.Output_1 - } - return nil -} - -func (m *SwapClaimView_Visible) GetOutput_2() *v1alpha1.NoteView { - if m != nil { - return m.Output_2 - } - return nil -} - -type SwapClaimView_Opaque struct { - SwapClaim *SwapClaim `protobuf:"bytes,1,opt,name=swap_claim,json=swapClaim,proto3" json:"swap_claim,omitempty"` -} - -func (m *SwapClaimView_Opaque) Reset() { *m = SwapClaimView_Opaque{} } -func (m *SwapClaimView_Opaque) String() string { return proto.CompactTextString(m) } -func (*SwapClaimView_Opaque) ProtoMessage() {} -func (*SwapClaimView_Opaque) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{9, 1} -} -func (m *SwapClaimView_Opaque) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapClaimView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapClaimView_Opaque.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 *SwapClaimView_Opaque) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapClaimView_Opaque.Merge(m, src) -} -func (m *SwapClaimView_Opaque) XXX_Size() int { - return m.Size() -} -func (m *SwapClaimView_Opaque) XXX_DiscardUnknown() { - xxx_messageInfo_SwapClaimView_Opaque.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapClaimView_Opaque proto.InternalMessageInfo - -func (m *SwapClaimView_Opaque) GetSwapClaim() *SwapClaim { - if m != nil { - return m.SwapClaim - } - return nil -} - -// Holds two asset IDs. Ordering doesn't reflect trading direction. Instead, we -// require `asset_1 < asset_2` as field elements, to ensure a canonical -// representation of an unordered pair. -type TradingPair struct { - // The first asset of the pair. - Asset_1 *v1alpha1.AssetId `protobuf:"bytes,1,opt,name=asset_1,json=asset1,proto3" json:"asset_1,omitempty"` - // The second asset of the pair. - Asset_2 *v1alpha1.AssetId `protobuf:"bytes,2,opt,name=asset_2,json=asset2,proto3" json:"asset_2,omitempty"` -} - -func (m *TradingPair) Reset() { *m = TradingPair{} } -func (m *TradingPair) String() string { return proto.CompactTextString(m) } -func (*TradingPair) ProtoMessage() {} -func (*TradingPair) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{10} -} -func (m *TradingPair) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *TradingPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_TradingPair.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 *TradingPair) XXX_Merge(src proto.Message) { - xxx_messageInfo_TradingPair.Merge(m, src) -} -func (m *TradingPair) XXX_Size() int { - return m.Size() -} -func (m *TradingPair) XXX_DiscardUnknown() { - xxx_messageInfo_TradingPair.DiscardUnknown(m) -} - -var xxx_messageInfo_TradingPair proto.InternalMessageInfo - -func (m *TradingPair) GetAsset_1() *v1alpha1.AssetId { - if m != nil { - return m.Asset_1 - } - return nil -} - -func (m *TradingPair) GetAsset_2() *v1alpha1.AssetId { - if m != nil { - return m.Asset_2 - } - return nil -} - -// Encodes a trading pair starting from asset `start` -// and ending on asset `end`. -type DirectedTradingPair struct { - // The start asset of the pair. - Start *v1alpha1.AssetId `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"` - // The end asset of the pair. - End *v1alpha1.AssetId `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"` -} - -func (m *DirectedTradingPair) Reset() { *m = DirectedTradingPair{} } -func (m *DirectedTradingPair) String() string { return proto.CompactTextString(m) } -func (*DirectedTradingPair) ProtoMessage() {} -func (*DirectedTradingPair) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{11} -} -func (m *DirectedTradingPair) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DirectedTradingPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DirectedTradingPair.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 *DirectedTradingPair) XXX_Merge(src proto.Message) { - xxx_messageInfo_DirectedTradingPair.Merge(m, src) -} -func (m *DirectedTradingPair) XXX_Size() int { - return m.Size() -} -func (m *DirectedTradingPair) XXX_DiscardUnknown() { - xxx_messageInfo_DirectedTradingPair.DiscardUnknown(m) -} - -var xxx_messageInfo_DirectedTradingPair proto.InternalMessageInfo - -func (m *DirectedTradingPair) GetStart() *v1alpha1.AssetId { - if m != nil { - return m.Start - } - return nil -} - -func (m *DirectedTradingPair) GetEnd() *v1alpha1.AssetId { - if m != nil { - return m.End - } - return nil -} - -// Records the result of a batch swap on-chain. -// -// Used as a public input to a swap claim proof, as it implies the effective -// clearing price for the batch. -type BatchSwapOutputData struct { - // The total amount of asset 1 that was input to the batch swap. - Delta_1 *v1alpha1.Amount `protobuf:"bytes,1,opt,name=delta_1,json=delta1,proto3" json:"delta_1,omitempty"` - // The total amount of asset 2 that was input to the batch swap. - Delta_2 *v1alpha1.Amount `protobuf:"bytes,2,opt,name=delta_2,json=delta2,proto3" json:"delta_2,omitempty"` - // The total amount of asset 1 that was output from the batch swap for 2=>1 trades. - Lambda_1 *v1alpha1.Amount `protobuf:"bytes,3,opt,name=lambda_1,json=lambda1,proto3" json:"lambda_1,omitempty"` - // The total amount of asset 2 that was output from the batch swap for 1=>2 trades. - Lambda_2 *v1alpha1.Amount `protobuf:"bytes,4,opt,name=lambda_2,json=lambda2,proto3" json:"lambda_2,omitempty"` - // The total amount of asset 1 that was returned unfilled from the batch swap for 1=>2 trades. - Unfilled_1 *v1alpha1.Amount `protobuf:"bytes,5,opt,name=unfilled_1,json=unfilled1,proto3" json:"unfilled_1,omitempty"` - // The total amount of asset 2 that was returned unfilled from the batch swap for 2=>1 trades. - Unfilled_2 *v1alpha1.Amount `protobuf:"bytes,6,opt,name=unfilled_2,json=unfilled2,proto3" json:"unfilled_2,omitempty"` - // The height for which the batch swap data is valid. - Height uint64 `protobuf:"varint,7,opt,name=height,proto3" json:"height,omitempty"` - // The trading pair associated with the batch swap. - TradingPair *TradingPair `protobuf:"bytes,8,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` - // The starting block height of the epoch for which the batch swap data is valid. - EpochStartingHeight uint64 `protobuf:"varint,9,opt,name=epoch_starting_height,json=epochStartingHeight,proto3" json:"epoch_starting_height,omitempty"` -} - -func (m *BatchSwapOutputData) Reset() { *m = BatchSwapOutputData{} } -func (m *BatchSwapOutputData) String() string { return proto.CompactTextString(m) } -func (*BatchSwapOutputData) ProtoMessage() {} -func (*BatchSwapOutputData) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{12} -} -func (m *BatchSwapOutputData) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *BatchSwapOutputData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_BatchSwapOutputData.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 *BatchSwapOutputData) XXX_Merge(src proto.Message) { - xxx_messageInfo_BatchSwapOutputData.Merge(m, src) -} -func (m *BatchSwapOutputData) XXX_Size() int { - return m.Size() -} -func (m *BatchSwapOutputData) XXX_DiscardUnknown() { - xxx_messageInfo_BatchSwapOutputData.DiscardUnknown(m) -} - -var xxx_messageInfo_BatchSwapOutputData proto.InternalMessageInfo - -func (m *BatchSwapOutputData) GetDelta_1() *v1alpha1.Amount { - if m != nil { - return m.Delta_1 - } - return nil -} - -func (m *BatchSwapOutputData) GetDelta_2() *v1alpha1.Amount { - if m != nil { - return m.Delta_2 - } - return nil -} - -func (m *BatchSwapOutputData) GetLambda_1() *v1alpha1.Amount { - if m != nil { - return m.Lambda_1 - } - return nil -} - -func (m *BatchSwapOutputData) GetLambda_2() *v1alpha1.Amount { - if m != nil { - return m.Lambda_2 - } - return nil -} - -func (m *BatchSwapOutputData) GetUnfilled_1() *v1alpha1.Amount { - if m != nil { - return m.Unfilled_1 - } - return nil -} - -func (m *BatchSwapOutputData) GetUnfilled_2() *v1alpha1.Amount { - if m != nil { - return m.Unfilled_2 - } - return nil -} - -func (m *BatchSwapOutputData) GetHeight() uint64 { - if m != nil { - return m.Height - } - return 0 -} - -func (m *BatchSwapOutputData) GetTradingPair() *TradingPair { - if m != nil { - return m.TradingPair - } - return nil -} - -func (m *BatchSwapOutputData) GetEpochStartingHeight() uint64 { - if m != nil { - return m.EpochStartingHeight - } - return 0 -} - -// The trading function for a specific pair. -// For a pair (asset_1, asset_2), a trading function is defined by: -// `phi(R) = p*R_1 + q*R_2` and `gamma = 1 - fee`. -// The trading function is frequently referred to as "phi". -type TradingFunction struct { - Component *BareTradingFunction `protobuf:"bytes,1,opt,name=component,proto3" json:"component,omitempty"` - Pair *TradingPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` -} - -func (m *TradingFunction) Reset() { *m = TradingFunction{} } -func (m *TradingFunction) String() string { return proto.CompactTextString(m) } -func (*TradingFunction) ProtoMessage() {} -func (*TradingFunction) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{13} -} -func (m *TradingFunction) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *TradingFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_TradingFunction.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 *TradingFunction) XXX_Merge(src proto.Message) { - xxx_messageInfo_TradingFunction.Merge(m, src) -} -func (m *TradingFunction) XXX_Size() int { - return m.Size() -} -func (m *TradingFunction) XXX_DiscardUnknown() { - xxx_messageInfo_TradingFunction.DiscardUnknown(m) -} - -var xxx_messageInfo_TradingFunction proto.InternalMessageInfo - -func (m *TradingFunction) GetComponent() *BareTradingFunction { - if m != nil { - return m.Component - } - return nil -} - -func (m *TradingFunction) GetPair() *TradingPair { - if m != nil { - return m.Pair - } - return nil -} - -// The minimum amount of data describing a trading function. -// -// This implicitly treats the trading function as being between assets 1 and 2, -// without specifying what those assets are, to avoid duplicating data (each -// asset ID alone is twice the size of the trading function). -type BareTradingFunction struct { - Fee uint32 `protobuf:"varint,1,opt,name=fee,proto3" json:"fee,omitempty"` - // This is not actually an amount, it's an integer the same width as an amount - P *v1alpha1.Amount `protobuf:"bytes,2,opt,name=p,proto3" json:"p,omitempty"` - // This is not actually an amount, it's an integer the same width as an amount - Q *v1alpha1.Amount `protobuf:"bytes,3,opt,name=q,proto3" json:"q,omitempty"` -} - -func (m *BareTradingFunction) Reset() { *m = BareTradingFunction{} } -func (m *BareTradingFunction) String() string { return proto.CompactTextString(m) } -func (*BareTradingFunction) ProtoMessage() {} -func (*BareTradingFunction) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{14} -} -func (m *BareTradingFunction) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *BareTradingFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_BareTradingFunction.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 *BareTradingFunction) XXX_Merge(src proto.Message) { - xxx_messageInfo_BareTradingFunction.Merge(m, src) -} -func (m *BareTradingFunction) XXX_Size() int { - return m.Size() -} -func (m *BareTradingFunction) XXX_DiscardUnknown() { - xxx_messageInfo_BareTradingFunction.DiscardUnknown(m) -} - -var xxx_messageInfo_BareTradingFunction proto.InternalMessageInfo - -func (m *BareTradingFunction) GetFee() uint32 { - if m != nil { - return m.Fee - } - return 0 -} - -func (m *BareTradingFunction) GetP() *v1alpha1.Amount { - if m != nil { - return m.P - } - return nil -} - -func (m *BareTradingFunction) GetQ() *v1alpha1.Amount { - if m != nil { - return m.Q - } - return nil -} - -// The reserves of a position. -// -// Like a position, this implicitly treats the trading function as being -// between assets 1 and 2, without specifying what those assets are, to avoid -// duplicating data (each asset ID alone is four times the size of the -// reserves). -type Reserves struct { - R1 *v1alpha1.Amount `protobuf:"bytes,1,opt,name=r1,proto3" json:"r1,omitempty"` - R2 *v1alpha1.Amount `protobuf:"bytes,2,opt,name=r2,proto3" json:"r2,omitempty"` -} - -func (m *Reserves) Reset() { *m = Reserves{} } -func (m *Reserves) String() string { return proto.CompactTextString(m) } -func (*Reserves) ProtoMessage() {} -func (*Reserves) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{15} -} -func (m *Reserves) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Reserves) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Reserves.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 *Reserves) XXX_Merge(src proto.Message) { - xxx_messageInfo_Reserves.Merge(m, src) -} -func (m *Reserves) XXX_Size() int { - return m.Size() -} -func (m *Reserves) XXX_DiscardUnknown() { - xxx_messageInfo_Reserves.DiscardUnknown(m) -} - -var xxx_messageInfo_Reserves proto.InternalMessageInfo - -func (m *Reserves) GetR1() *v1alpha1.Amount { - if m != nil { - return m.R1 - } - return nil -} - -func (m *Reserves) GetR2() *v1alpha1.Amount { - if m != nil { - return m.R2 - } - return nil -} - -// Data identifying a position. -type Position struct { - Phi *TradingFunction `protobuf:"bytes,1,opt,name=phi,proto3" json:"phi,omitempty"` - // A random value used to disambiguate different positions with the exact same - // trading function. The chain should reject newly created positions with the - // same nonce as an existing position. This ensures that `PositionId`s will - // be unique, and allows us to track position ownership with a - // sequence of stateful NFTs based on the `PositionId`. - Nonce []byte `protobuf:"bytes,2,opt,name=nonce,proto3" json:"nonce,omitempty"` - State *PositionState `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"` - Reserves *Reserves `protobuf:"bytes,4,opt,name=reserves,proto3" json:"reserves,omitempty"` - // / If set to true, the position is a limit-order and will be closed - // / immediately after being filled. - CloseOnFill bool `protobuf:"varint,5,opt,name=close_on_fill,json=closeOnFill,proto3" json:"close_on_fill,omitempty"` -} - -func (m *Position) Reset() { *m = Position{} } -func (m *Position) String() string { return proto.CompactTextString(m) } -func (*Position) ProtoMessage() {} -func (*Position) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{16} -} -func (m *Position) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Position.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 *Position) XXX_Merge(src proto.Message) { - xxx_messageInfo_Position.Merge(m, src) -} -func (m *Position) XXX_Size() int { - return m.Size() -} -func (m *Position) XXX_DiscardUnknown() { - xxx_messageInfo_Position.DiscardUnknown(m) -} - -var xxx_messageInfo_Position proto.InternalMessageInfo - -func (m *Position) GetPhi() *TradingFunction { - if m != nil { - return m.Phi - } - return nil -} - -func (m *Position) GetNonce() []byte { - if m != nil { - return m.Nonce - } - return nil -} - -func (m *Position) GetState() *PositionState { - if m != nil { - return m.State - } - return nil -} - -func (m *Position) GetReserves() *Reserves { - if m != nil { - return m.Reserves - } - return nil -} - -func (m *Position) GetCloseOnFill() bool { - if m != nil { - return m.CloseOnFill - } - return false -} - -// A hash of a `Position`. -type PositionId struct { - // The bytes of the position ID. - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` - // Alternatively, a Bech32m-encoded string representation of the `inner` - // bytes. - // - // NOTE: implementations are not required to support parsing this field. - // Implementations should prefer to encode the bytes in all messages they - // produce. Implementations must not accept messages with both `inner` and - // `alt_bech32m` set. - AltBech32M string `protobuf:"bytes,2,opt,name=alt_bech32m,json=altBech32m,proto3" json:"alt_bech32m,omitempty"` -} - -func (m *PositionId) Reset() { *m = PositionId{} } -func (m *PositionId) String() string { return proto.CompactTextString(m) } -func (*PositionId) ProtoMessage() {} -func (*PositionId) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{17} -} -func (m *PositionId) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PositionId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_PositionId.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 *PositionId) XXX_Merge(src proto.Message) { - xxx_messageInfo_PositionId.Merge(m, src) -} -func (m *PositionId) XXX_Size() int { - return m.Size() -} -func (m *PositionId) XXX_DiscardUnknown() { - xxx_messageInfo_PositionId.DiscardUnknown(m) -} - -var xxx_messageInfo_PositionId proto.InternalMessageInfo - -func (m *PositionId) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - -func (m *PositionId) GetAltBech32M() string { - if m != nil { - return m.AltBech32M - } - return "" -} - -// The state of a position. -type PositionState struct { - State PositionState_PositionStateEnum `protobuf:"varint,1,opt,name=state,proto3,enum=penumbra.core.dex.v1alpha1.PositionState_PositionStateEnum" json:"state,omitempty"` -} - -func (m *PositionState) Reset() { *m = PositionState{} } -func (m *PositionState) String() string { return proto.CompactTextString(m) } -func (*PositionState) ProtoMessage() {} -func (*PositionState) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{18} -} -func (m *PositionState) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PositionState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_PositionState.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 *PositionState) XXX_Merge(src proto.Message) { - xxx_messageInfo_PositionState.Merge(m, src) -} -func (m *PositionState) XXX_Size() int { - return m.Size() -} -func (m *PositionState) XXX_DiscardUnknown() { - xxx_messageInfo_PositionState.DiscardUnknown(m) -} - -var xxx_messageInfo_PositionState proto.InternalMessageInfo - -func (m *PositionState) GetState() PositionState_PositionStateEnum { - if m != nil { - return m.State - } - return PositionState_POSITION_STATE_ENUM_UNSPECIFIED -} - -// An LPNFT tracking both ownership and state of a position. -// -// Tracking the state as part of the LPNFT means that all LP-related actions can -// be authorized by spending funds: a state transition (e.g., closing a -// position) is modeled as spending an "open position LPNFT" and minting a -// "closed position LPNFT" for the same (globally unique) position ID. -// -// This means that the LP mechanics can be agnostic to the mechanism used to -// record custody and spend authorization. For instance, they can be recorded -// in the shielded pool, where custody is based on off-chain keys, or they could -// be recorded in a programmatic on-chain account (in the future, e.g., to -// support interchain accounts). This also means that LP-related actions don't -// require any cryptographic implementation (proofs, signatures, etc), other -// than hooking into the value commitment mechanism used for transaction -// balances. -type LpNft struct { - PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` - State *PositionState `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"` -} - -func (m *LpNft) Reset() { *m = LpNft{} } -func (m *LpNft) String() string { return proto.CompactTextString(m) } -func (*LpNft) ProtoMessage() {} -func (*LpNft) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{19} -} -func (m *LpNft) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *LpNft) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_LpNft.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 *LpNft) XXX_Merge(src proto.Message) { - xxx_messageInfo_LpNft.Merge(m, src) -} -func (m *LpNft) XXX_Size() int { - return m.Size() -} -func (m *LpNft) XXX_DiscardUnknown() { - xxx_messageInfo_LpNft.DiscardUnknown(m) -} - -var xxx_messageInfo_LpNft proto.InternalMessageInfo - -func (m *LpNft) GetPositionId() *PositionId { - if m != nil { - return m.PositionId - } - return nil -} - -func (m *LpNft) GetState() *PositionState { - if m != nil { - return m.State - } - return nil -} - -// A transaction action that opens a new position. -// -// This action's contribution to the transaction's value balance is to consume -// the initial reserves and contribute an opened position NFT. -type PositionOpen struct { - // Contains the data defining the position, sufficient to compute its `PositionId`. - // - // Positions are immutable, so the `PositionData` (and hence the `PositionId`) - // are unchanged over the entire lifetime of the position. - Position *Position `protobuf:"bytes,1,opt,name=position,proto3" json:"position,omitempty"` -} - -func (m *PositionOpen) Reset() { *m = PositionOpen{} } -func (m *PositionOpen) String() string { return proto.CompactTextString(m) } -func (*PositionOpen) ProtoMessage() {} -func (*PositionOpen) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{20} -} -func (m *PositionOpen) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PositionOpen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_PositionOpen.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 *PositionOpen) XXX_Merge(src proto.Message) { - xxx_messageInfo_PositionOpen.Merge(m, src) -} -func (m *PositionOpen) XXX_Size() int { - return m.Size() -} -func (m *PositionOpen) XXX_DiscardUnknown() { - xxx_messageInfo_PositionOpen.DiscardUnknown(m) -} - -var xxx_messageInfo_PositionOpen proto.InternalMessageInfo - -func (m *PositionOpen) GetPosition() *Position { - if m != nil { - return m.Position - } - return nil -} - -// A transaction action that closes a position. -// -// This action's contribution to the transaction's value balance is to consume -// an opened position NFT and contribute a closed position NFT. -// -// Closing a position does not immediately withdraw funds, because Penumbra -// transactions (like any ZK transaction model) are early-binding: the prover -// must know the state transition they prove knowledge of, and they cannot know -// the final reserves with certainty until after the position has been deactivated. -type PositionClose struct { - PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` -} - -func (m *PositionClose) Reset() { *m = PositionClose{} } -func (m *PositionClose) String() string { return proto.CompactTextString(m) } -func (*PositionClose) ProtoMessage() {} -func (*PositionClose) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{21} -} -func (m *PositionClose) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PositionClose) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_PositionClose.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 *PositionClose) XXX_Merge(src proto.Message) { - xxx_messageInfo_PositionClose.Merge(m, src) -} -func (m *PositionClose) XXX_Size() int { - return m.Size() -} -func (m *PositionClose) XXX_DiscardUnknown() { - xxx_messageInfo_PositionClose.DiscardUnknown(m) -} - -var xxx_messageInfo_PositionClose proto.InternalMessageInfo - -func (m *PositionClose) GetPositionId() *PositionId { - if m != nil { - return m.PositionId - } - return nil -} - -// A transaction action that withdraws funds from a closed position. -// -// This action's contribution to the transaction's value balance is to consume a -// closed position NFT and contribute a withdrawn position NFT, as well as all -// of the funds that were in the position at the time of closing. -type PositionWithdraw struct { - PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` - // A transparent (zero blinding factor) commitment to the position's final reserves and fees. - // - // The chain will check this commitment by recomputing it with the on-chain state. - ReservesCommitment *v1alpha1.BalanceCommitment `protobuf:"bytes,2,opt,name=reserves_commitment,json=reservesCommitment,proto3" json:"reserves_commitment,omitempty"` -} - -func (m *PositionWithdraw) Reset() { *m = PositionWithdraw{} } -func (m *PositionWithdraw) String() string { return proto.CompactTextString(m) } -func (*PositionWithdraw) ProtoMessage() {} -func (*PositionWithdraw) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{22} -} -func (m *PositionWithdraw) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PositionWithdraw) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_PositionWithdraw.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 *PositionWithdraw) XXX_Merge(src proto.Message) { - xxx_messageInfo_PositionWithdraw.Merge(m, src) -} -func (m *PositionWithdraw) XXX_Size() int { - return m.Size() -} -func (m *PositionWithdraw) XXX_DiscardUnknown() { - xxx_messageInfo_PositionWithdraw.DiscardUnknown(m) -} - -var xxx_messageInfo_PositionWithdraw proto.InternalMessageInfo - -func (m *PositionWithdraw) GetPositionId() *PositionId { - if m != nil { - return m.PositionId - } - return nil -} - -func (m *PositionWithdraw) GetReservesCommitment() *v1alpha1.BalanceCommitment { - if m != nil { - return m.ReservesCommitment - } - return nil -} - -// A transaction action that claims retroactive rewards for a historical -// position. -// -// This action's contribution to the transaction's value balance is to consume a -// withdrawn position NFT and contribute its reward balance. -type PositionRewardClaim struct { - PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` - // A transparent (zero blinding factor) commitment to the position's accumulated rewards. - // - // The chain will check this commitment by recomputing it with the on-chain state. - RewardsCommitment *v1alpha1.BalanceCommitment `protobuf:"bytes,2,opt,name=rewards_commitment,json=rewardsCommitment,proto3" json:"rewards_commitment,omitempty"` -} - -func (m *PositionRewardClaim) Reset() { *m = PositionRewardClaim{} } -func (m *PositionRewardClaim) String() string { return proto.CompactTextString(m) } -func (*PositionRewardClaim) ProtoMessage() {} -func (*PositionRewardClaim) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{23} -} -func (m *PositionRewardClaim) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PositionRewardClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_PositionRewardClaim.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 *PositionRewardClaim) XXX_Merge(src proto.Message) { - xxx_messageInfo_PositionRewardClaim.Merge(m, src) -} -func (m *PositionRewardClaim) XXX_Size() int { - return m.Size() -} -func (m *PositionRewardClaim) XXX_DiscardUnknown() { - xxx_messageInfo_PositionRewardClaim.DiscardUnknown(m) -} - -var xxx_messageInfo_PositionRewardClaim proto.InternalMessageInfo - -func (m *PositionRewardClaim) GetPositionId() *PositionId { - if m != nil { - return m.PositionId - } - return nil -} - -func (m *PositionRewardClaim) GetRewardsCommitment() *v1alpha1.BalanceCommitment { - if m != nil { - return m.RewardsCommitment - } - return nil -} - -// Contains the entire execution of a particular swap. -type SwapExecution struct { - Traces []*SwapExecution_Trace `protobuf:"bytes,1,rep,name=traces,proto3" json:"traces,omitempty"` - // The total input amount for this execution. - Input *v1alpha1.Value `protobuf:"bytes,2,opt,name=input,proto3" json:"input,omitempty"` - // The total output amount for this execution. - Output *v1alpha1.Value `protobuf:"bytes,3,opt,name=output,proto3" json:"output,omitempty"` -} - -func (m *SwapExecution) Reset() { *m = SwapExecution{} } -func (m *SwapExecution) String() string { return proto.CompactTextString(m) } -func (*SwapExecution) ProtoMessage() {} -func (*SwapExecution) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{24} -} -func (m *SwapExecution) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapExecution.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 *SwapExecution) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapExecution.Merge(m, src) -} -func (m *SwapExecution) XXX_Size() int { - return m.Size() -} -func (m *SwapExecution) XXX_DiscardUnknown() { - xxx_messageInfo_SwapExecution.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapExecution proto.InternalMessageInfo - -func (m *SwapExecution) GetTraces() []*SwapExecution_Trace { - if m != nil { - return m.Traces - } - return nil -} - -func (m *SwapExecution) GetInput() *v1alpha1.Value { - if m != nil { - return m.Input - } - return nil -} - -func (m *SwapExecution) GetOutput() *v1alpha1.Value { - if m != nil { - return m.Output - } - return nil -} - -// Contains all individual steps consisting of a trade trace. -type SwapExecution_Trace struct { - // Each step in the trade trace. - Value []*v1alpha1.Value `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"` -} - -func (m *SwapExecution_Trace) Reset() { *m = SwapExecution_Trace{} } -func (m *SwapExecution_Trace) String() string { return proto.CompactTextString(m) } -func (*SwapExecution_Trace) ProtoMessage() {} -func (*SwapExecution_Trace) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{24, 0} -} -func (m *SwapExecution_Trace) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapExecution_Trace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapExecution_Trace.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 *SwapExecution_Trace) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapExecution_Trace.Merge(m, src) -} -func (m *SwapExecution_Trace) XXX_Size() int { - return m.Size() -} -func (m *SwapExecution_Trace) XXX_DiscardUnknown() { - xxx_messageInfo_SwapExecution_Trace.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapExecution_Trace proto.InternalMessageInfo - -func (m *SwapExecution_Trace) GetValue() []*v1alpha1.Value { - if m != nil { - return m.Value - } - return nil -} - -// Contains private and public data for withdrawing funds from a closed position. -type PositionWithdrawPlan struct { - Reserves *Reserves `protobuf:"bytes,1,opt,name=reserves,proto3" json:"reserves,omitempty"` - PositionId *PositionId `protobuf:"bytes,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` - Pair *TradingPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` -} - -func (m *PositionWithdrawPlan) Reset() { *m = PositionWithdrawPlan{} } -func (m *PositionWithdrawPlan) String() string { return proto.CompactTextString(m) } -func (*PositionWithdrawPlan) ProtoMessage() {} -func (*PositionWithdrawPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{25} -} -func (m *PositionWithdrawPlan) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PositionWithdrawPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_PositionWithdrawPlan.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 *PositionWithdrawPlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_PositionWithdrawPlan.Merge(m, src) -} -func (m *PositionWithdrawPlan) XXX_Size() int { - return m.Size() -} -func (m *PositionWithdrawPlan) XXX_DiscardUnknown() { - xxx_messageInfo_PositionWithdrawPlan.DiscardUnknown(m) -} - -var xxx_messageInfo_PositionWithdrawPlan proto.InternalMessageInfo - -func (m *PositionWithdrawPlan) GetReserves() *Reserves { - if m != nil { - return m.Reserves - } - return nil -} - -func (m *PositionWithdrawPlan) GetPositionId() *PositionId { - if m != nil { - return m.PositionId - } - return nil -} - -func (m *PositionWithdrawPlan) GetPair() *TradingPair { - if m != nil { - return m.Pair - } - return nil -} - -// Contains private and public data for claiming rewards from a position. -type PositionRewardClaimPlan struct { - Reserves *Reserves `protobuf:"bytes,1,opt,name=reserves,proto3" json:"reserves,omitempty"` -} - -func (m *PositionRewardClaimPlan) Reset() { *m = PositionRewardClaimPlan{} } -func (m *PositionRewardClaimPlan) String() string { return proto.CompactTextString(m) } -func (*PositionRewardClaimPlan) ProtoMessage() {} -func (*PositionRewardClaimPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_d1eba752ca2f0d70, []int{26} -} -func (m *PositionRewardClaimPlan) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PositionRewardClaimPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_PositionRewardClaimPlan.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 *PositionRewardClaimPlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_PositionRewardClaimPlan.Merge(m, src) -} -func (m *PositionRewardClaimPlan) XXX_Size() int { - return m.Size() -} -func (m *PositionRewardClaimPlan) XXX_DiscardUnknown() { - xxx_messageInfo_PositionRewardClaimPlan.DiscardUnknown(m) -} - -var xxx_messageInfo_PositionRewardClaimPlan proto.InternalMessageInfo - -func (m *PositionRewardClaimPlan) GetReserves() *Reserves { - if m != nil { - return m.Reserves - } - return nil -} - -func init() { - proto.RegisterEnum("penumbra.core.dex.v1alpha1.PositionState_PositionStateEnum", PositionState_PositionStateEnum_name, PositionState_PositionStateEnum_value) - proto.RegisterType((*Swap)(nil), "penumbra.core.dex.v1alpha1.Swap") - proto.RegisterType((*SwapClaim)(nil), "penumbra.core.dex.v1alpha1.SwapClaim") - proto.RegisterType((*SwapClaimBody)(nil), "penumbra.core.dex.v1alpha1.SwapClaimBody") - proto.RegisterType((*SwapBody)(nil), "penumbra.core.dex.v1alpha1.SwapBody") - proto.RegisterType((*SwapPayload)(nil), "penumbra.core.dex.v1alpha1.SwapPayload") - proto.RegisterType((*SwapPlaintext)(nil), "penumbra.core.dex.v1alpha1.SwapPlaintext") - proto.RegisterType((*SwapPlan)(nil), "penumbra.core.dex.v1alpha1.SwapPlan") - proto.RegisterType((*SwapClaimPlan)(nil), "penumbra.core.dex.v1alpha1.SwapClaimPlan") - proto.RegisterType((*SwapView)(nil), "penumbra.core.dex.v1alpha1.SwapView") - proto.RegisterType((*SwapView_Visible)(nil), "penumbra.core.dex.v1alpha1.SwapView.Visible") - proto.RegisterType((*SwapView_Opaque)(nil), "penumbra.core.dex.v1alpha1.SwapView.Opaque") - proto.RegisterType((*SwapClaimView)(nil), "penumbra.core.dex.v1alpha1.SwapClaimView") - proto.RegisterType((*SwapClaimView_Visible)(nil), "penumbra.core.dex.v1alpha1.SwapClaimView.Visible") - proto.RegisterType((*SwapClaimView_Opaque)(nil), "penumbra.core.dex.v1alpha1.SwapClaimView.Opaque") - proto.RegisterType((*TradingPair)(nil), "penumbra.core.dex.v1alpha1.TradingPair") - proto.RegisterType((*DirectedTradingPair)(nil), "penumbra.core.dex.v1alpha1.DirectedTradingPair") - proto.RegisterType((*BatchSwapOutputData)(nil), "penumbra.core.dex.v1alpha1.BatchSwapOutputData") - proto.RegisterType((*TradingFunction)(nil), "penumbra.core.dex.v1alpha1.TradingFunction") - proto.RegisterType((*BareTradingFunction)(nil), "penumbra.core.dex.v1alpha1.BareTradingFunction") - proto.RegisterType((*Reserves)(nil), "penumbra.core.dex.v1alpha1.Reserves") - proto.RegisterType((*Position)(nil), "penumbra.core.dex.v1alpha1.Position") - proto.RegisterType((*PositionId)(nil), "penumbra.core.dex.v1alpha1.PositionId") - proto.RegisterType((*PositionState)(nil), "penumbra.core.dex.v1alpha1.PositionState") - proto.RegisterType((*LpNft)(nil), "penumbra.core.dex.v1alpha1.LpNft") - proto.RegisterType((*PositionOpen)(nil), "penumbra.core.dex.v1alpha1.PositionOpen") - proto.RegisterType((*PositionClose)(nil), "penumbra.core.dex.v1alpha1.PositionClose") - proto.RegisterType((*PositionWithdraw)(nil), "penumbra.core.dex.v1alpha1.PositionWithdraw") - proto.RegisterType((*PositionRewardClaim)(nil), "penumbra.core.dex.v1alpha1.PositionRewardClaim") - proto.RegisterType((*SwapExecution)(nil), "penumbra.core.dex.v1alpha1.SwapExecution") - proto.RegisterType((*SwapExecution_Trace)(nil), "penumbra.core.dex.v1alpha1.SwapExecution.Trace") - proto.RegisterType((*PositionWithdrawPlan)(nil), "penumbra.core.dex.v1alpha1.PositionWithdrawPlan") - proto.RegisterType((*PositionRewardClaimPlan)(nil), "penumbra.core.dex.v1alpha1.PositionRewardClaimPlan") -} - -func init() { - proto.RegisterFile("penumbra/core/dex/v1alpha1/dex.proto", fileDescriptor_d1eba752ca2f0d70) -} - -var fileDescriptor_d1eba752ca2f0d70 = []byte{ - // 1824 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x59, 0xcd, 0x6f, 0x1b, 0xc7, - 0x15, 0xd7, 0x2e, 0x29, 0x8a, 0x7c, 0xa4, 0x14, 0x79, 0x94, 0xb6, 0x02, 0x8b, 0xc8, 0xce, 0xd6, - 0x4e, 0xdc, 0xa4, 0xa0, 0xc2, 0x75, 0x0a, 0x04, 0x72, 0x12, 0x47, 0xfc, 0x90, 0xc5, 0x24, 0xa2, - 0xd8, 0x91, 0x62, 0x17, 0xa9, 0xd1, 0xc5, 0x68, 0x77, 0x64, 0x2e, 0xb0, 0xdc, 0x5d, 0xef, 0x0e, - 0x25, 0xea, 0x5a, 0xf4, 0xe3, 0x54, 0xb4, 0x39, 0xf5, 0x54, 0x14, 0xe9, 0xb1, 0x7f, 0x43, 0x3f, - 0xae, 0x45, 0x4e, 0x06, 0x7a, 0x68, 0x4f, 0x45, 0x61, 0x1f, 0x0a, 0xf4, 0x2f, 0xe8, 0xa1, 0x87, - 0x62, 0x66, 0x67, 0xc8, 0x95, 0x44, 0x99, 0xa4, 0xac, 0x5e, 0x7a, 0xe3, 0xcc, 0xbc, 0xdf, 0x6f, - 0xdf, 0xd7, 0xbc, 0xf7, 0x76, 0x09, 0x37, 0x43, 0xea, 0xf7, 0x7b, 0x07, 0x11, 0x59, 0xb7, 0x83, - 0x88, 0xae, 0x3b, 0x74, 0xb0, 0x7e, 0x54, 0x25, 0x5e, 0xd8, 0x25, 0x55, 0xbe, 0xa8, 0x84, 0x51, - 0xc0, 0x02, 0x54, 0x56, 0x52, 0x15, 0x2e, 0x55, 0xe1, 0x07, 0x4a, 0xaa, 0xfc, 0xd6, 0x69, 0x06, - 0x3b, 0x3a, 0x09, 0x59, 0x30, 0x22, 0x49, 0xd6, 0x09, 0x8f, 0xf1, 0x23, 0x0d, 0xb2, 0x7b, 0xc7, - 0x24, 0x44, 0x1f, 0xc1, 0x7c, 0x18, 0x05, 0xc1, 0xe1, 0xaa, 0x76, 0x43, 0xbb, 0x5d, 0x34, 0xdf, - 0xaa, 0x9c, 0x7e, 0x80, 0x04, 0x29, 0x92, 0xca, 0xe7, 0x9f, 0x70, 0x54, 0x87, 0x23, 0x70, 0x02, - 0x44, 0xef, 0x41, 0xf6, 0x20, 0x70, 0x4e, 0x56, 0xb3, 0x82, 0xe0, 0x66, 0xe5, 0x62, 0x0d, 0x2b, - 0x1c, 0x5b, 0x0b, 0x9c, 0x13, 0x2c, 0x10, 0xc6, 0xcf, 0x34, 0x28, 0xf0, 0xad, 0xba, 0x47, 0xdc, - 0x1e, 0x7a, 0x35, 0xad, 0x49, 0x49, 0xb1, 0x7f, 0x20, 0xd9, 0x75, 0xc1, 0xfe, 0xed, 0x49, 0xec, - 0x82, 0x6a, 0xf4, 0x08, 0x74, 0x0b, 0x96, 0x68, 0x18, 0xd8, 0x5d, 0xcb, 0xe9, 0x47, 0x84, 0xb9, - 0x81, 0xbf, 0xba, 0x70, 0x43, 0xbb, 0x9d, 0xc5, 0x8b, 0x62, 0xb7, 0x21, 0x37, 0x8d, 0xdf, 0x64, - 0x60, 0xf1, 0x14, 0x1c, 0x6d, 0x41, 0xc1, 0xef, 0x7b, 0x9e, 0x7b, 0xe8, 0xd2, 0x48, 0xfa, 0xe6, - 0xf6, 0x04, 0xdf, 0xb4, 0x95, 0x3c, 0x1e, 0x41, 0xd1, 0xbb, 0x90, 0x39, 0xa4, 0x54, 0xaa, 0x6f, - 0x4c, 0x60, 0xd8, 0xa2, 0x14, 0x73, 0x71, 0xf4, 0x43, 0x58, 0x09, 0xfa, 0x2c, 0xec, 0x33, 0xab, - 0x6a, 0xd9, 0x41, 0xaf, 0xe7, 0xb2, 0x1e, 0xf5, 0xd9, 0x6a, 0x46, 0xb0, 0x54, 0x26, 0xb0, 0xec, - 0x31, 0xc2, 0x68, 0x7d, 0x88, 0xc2, 0xd7, 0x12, 0xaa, 0xea, 0x68, 0x2b, 0xc5, 0x6f, 0xa6, 0xf9, - 0xb3, 0x2f, 0xc3, 0x6f, 0xa6, 0xf8, 0x3b, 0x50, 0x94, 0xfc, 0x0e, 0x61, 0x64, 0x35, 0x27, 0x78, - 0xd7, 0x5f, 0x14, 0xbc, 0x1a, 0x61, 0x76, 0x97, 0x87, 0x60, 0x57, 0xe0, 0x1a, 0x84, 0x11, 0x0c, - 0xc1, 0xf0, 0xb7, 0xf1, 0x6f, 0x1d, 0xf2, 0x2a, 0x7d, 0xd0, 0xc7, 0x50, 0x62, 0x11, 0x71, 0x5c, - 0xff, 0xb1, 0x15, 0x12, 0x57, 0xc5, 0xe7, 0xcd, 0x17, 0xf1, 0xef, 0x27, 0xf2, 0x1d, 0xe2, 0x46, - 0xb8, 0xc8, 0x46, 0x0b, 0xb4, 0x09, 0x05, 0x87, 0x7a, 0x8c, 0x58, 0x55, 0xcb, 0x95, 0x61, 0xba, - 0x35, 0xc1, 0x01, 0x9b, 0xbd, 0xa0, 0xef, 0x33, 0xbc, 0x20, 0x70, 0xd5, 0xd6, 0x88, 0xc2, 0xb4, - 0x5c, 0x19, 0xa3, 0x99, 0x28, 0xcc, 0x16, 0x7a, 0x08, 0x4b, 0x87, 0x94, 0x9e, 0x8f, 0xc5, 0x3b, - 0x13, 0x78, 0x6a, 0xc4, 0x23, 0xbe, 0x9d, 0x8e, 0xc6, 0xe2, 0x21, 0x4d, 0x2d, 0xd1, 0x26, 0x2c, - 0x84, 0xe4, 0xc4, 0x0b, 0x88, 0xb3, 0x3a, 0x3f, 0xd9, 0x4b, 0xe2, 0x72, 0x27, 0xe2, 0x58, 0xe1, - 0x8c, 0x1f, 0x6b, 0x50, 0x4c, 0x1d, 0xa0, 0x36, 0x40, 0x4a, 0x4f, 0xed, 0x52, 0x39, 0x93, 0x62, - 0x10, 0x77, 0xd4, 0x17, 0x00, 0xea, 0x58, 0xf1, 0x31, 0x09, 0x45, 0x18, 0x4a, 0x78, 0x71, 0xb8, - 0xcb, 0x9f, 0x6e, 0xfc, 0x44, 0xde, 0xd1, 0x8e, 0x47, 0x5c, 0x9f, 0xd1, 0x01, 0xfb, 0x3f, 0x4c, - 0x83, 0x7b, 0x50, 0xb0, 0x79, 0x09, 0xb2, 0x78, 0xcd, 0xc8, 0x4e, 0x5d, 0x33, 0xf2, 0x02, 0xb4, - 0x45, 0x29, 0xfa, 0x04, 0x16, 0x13, 0x02, 0xe2, 0x38, 0x11, 0x8d, 0x63, 0x19, 0xf4, 0x37, 0x26, - 0xe9, 0x91, 0x48, 0xe3, 0x92, 0x00, 0xcb, 0x15, 0xaf, 0xc8, 0x51, 0x4c, 0xa9, 0x23, 0xee, 0x6f, - 0x09, 0x27, 0x0b, 0xe3, 0x2f, 0x5a, 0x72, 0x13, 0x3b, 0x1e, 0xf1, 0x51, 0x07, 0x96, 0x78, 0xc4, - 0xac, 0x50, 0x05, 0x45, 0x06, 0x61, 0x62, 0xa1, 0x1e, 0x46, 0x11, 0x2f, 0xc6, 0xa7, 0x82, 0xfa, - 0x3a, 0x94, 0xf8, 0x4d, 0x38, 0xf0, 0x5c, 0x9f, 0x07, 0x47, 0xe6, 0x42, 0xf1, 0x90, 0xd2, 0x9a, - 0xdc, 0x42, 0xb7, 0x61, 0x59, 0x34, 0x87, 0xa1, 0x90, 0x15, 0x09, 0x7f, 0x97, 0xf0, 0x92, 0xd8, - 0x57, 0x82, 0x78, 0x8c, 0x64, 0x2c, 0xdc, 0x7a, 0x56, 0x72, 0xcf, 0xf8, 0x4a, 0x4f, 0x75, 0x80, - 0xff, 0x91, 0x69, 0x65, 0xc8, 0x87, 0x41, 0xec, 0x8a, 0x36, 0xa4, 0x8b, 0x36, 0x34, 0x5c, 0x9f, - 0xad, 0x98, 0x99, 0x97, 0xae, 0x98, 0x63, 0x5a, 0x5f, 0x76, 0x4c, 0xeb, 0x1b, 0xeb, 0xcc, 0xf9, - 0xa9, 0x9d, 0x99, 0x1b, 0xeb, 0xcc, 0xff, 0xc8, 0x62, 0xfd, 0xc0, 0xa5, 0xc7, 0x68, 0x1b, 0x16, - 0x8e, 0xdc, 0xd8, 0x3d, 0xf0, 0xa8, 0x74, 0xe0, 0x77, 0x26, 0x39, 0x90, 0xc3, 0x2a, 0x0f, 0x12, - 0xcc, 0xf6, 0x1c, 0x56, 0x70, 0xd4, 0x84, 0x5c, 0x10, 0x92, 0x27, 0x7d, 0xd5, 0x4e, 0xdf, 0x9e, - 0x8a, 0x68, 0x57, 0x40, 0xb6, 0xe7, 0xb0, 0x04, 0x97, 0xbf, 0xd0, 0x60, 0x41, 0xb2, 0xa3, 0x77, - 0x21, 0x2b, 0x2a, 0x4e, 0xa2, 0xd9, 0x8d, 0x49, 0x84, 0x58, 0x48, 0x8f, 0x49, 0x8d, 0xcc, 0xcb, - 0xa5, 0x46, 0xf9, 0x43, 0xc8, 0x25, 0x7a, 0x5e, 0x4e, 0xa3, 0x5a, 0x11, 0x0a, 0x42, 0xa3, 0x23, - 0x97, 0x1e, 0x1b, 0xff, 0x4c, 0x4f, 0x33, 0x22, 0x06, 0x3b, 0x67, 0x63, 0x50, 0x9d, 0x6a, 0x90, - 0xba, 0x28, 0x10, 0x1f, 0x9f, 0x09, 0xc4, 0x3b, 0xd3, 0xb3, 0x9d, 0x8b, 0xc6, 0x5f, 0x53, 0xd1, - 0x68, 0x00, 0x08, 0x2b, 0x44, 0x15, 0x92, 0x9a, 0xde, 0x9a, 0x8a, 0x1b, 0x0b, 0xf3, 0x93, 0x41, - 0xb2, 0x06, 0x79, 0x35, 0x3c, 0x49, 0xfd, 0xde, 0x9c, 0x34, 0xb9, 0x05, 0x8c, 0x72, 0xed, 0xf0, - 0x82, 0x1c, 0x95, 0x52, 0x1c, 0xa6, 0x8c, 0xed, 0xac, 0x1c, 0x66, 0xb9, 0x3d, 0x8c, 0xe9, 0x95, - 0xd8, 0x55, 0xbb, 0x06, 0xaf, 0x8c, 0x58, 0x92, 0x48, 0xff, 0x42, 0x83, 0x62, 0xaa, 0xa5, 0xa1, - 0x7b, 0xb0, 0x40, 0xe2, 0x98, 0x72, 0xcb, 0xb5, 0xe9, 0x0a, 0x3f, 0x97, 0x6e, 0x39, 0x38, 0x27, - 0x60, 0xd5, 0x11, 0x81, 0x29, 0x5d, 0x37, 0x1b, 0x81, 0x69, 0xfc, 0x5c, 0x83, 0x95, 0x86, 0x1b, - 0x51, 0x9b, 0x51, 0x27, 0xad, 0xd9, 0xfb, 0x30, 0x1f, 0x33, 0x12, 0xb1, 0x19, 0xf5, 0x4a, 0x40, - 0xe8, 0x3d, 0xc8, 0x50, 0xdf, 0x99, 0x51, 0x25, 0x0e, 0x31, 0xfe, 0x90, 0x85, 0x95, 0x31, 0x95, - 0x12, 0x7d, 0x08, 0x0b, 0xb2, 0xdf, 0x5f, 0x10, 0x8f, 0x0b, 0x5a, 0x75, 0x2e, 0xe9, 0xf6, 0x23, - 0xbc, 0x39, 0xdb, 0xb4, 0x90, 0xe0, 0x4d, 0xf4, 0x11, 0xe4, 0x3d, 0xd2, 0x3b, 0x70, 0xb8, 0x02, - 0xb3, 0xcd, 0x0a, 0x09, 0xac, 0x9a, 0x62, 0x30, 0xe5, 0xa8, 0x30, 0x1b, 0x83, 0xc9, 0xd3, 0xb2, - 0xef, 0x1f, 0xba, 0x9e, 0x47, 0x1d, 0xab, 0x2a, 0x27, 0x85, 0x29, 0x39, 0x0a, 0x0a, 0x58, 0x3d, - 0xc5, 0x62, 0xca, 0x51, 0x7f, 0x56, 0x16, 0x13, 0x7d, 0x1d, 0x72, 0x5d, 0xea, 0x3e, 0xee, 0x32, - 0xf9, 0x82, 0x26, 0x57, 0xe7, 0x66, 0xbc, 0xfc, 0x4b, 0xcc, 0x78, 0x26, 0x7c, 0x2d, 0xe9, 0x88, - 0x22, 0xa9, 0x38, 0xa5, 0x7c, 0x64, 0x41, 0x3c, 0x72, 0x45, 0x1c, 0xee, 0xc9, 0xb3, 0x6d, 0x71, - 0x64, 0xfc, 0x5a, 0x83, 0x57, 0x24, 0xe1, 0x56, 0xdf, 0xb7, 0x45, 0xcb, 0xdc, 0x81, 0x82, 0x1d, - 0xf4, 0xc2, 0xc0, 0x1f, 0xcd, 0xbf, 0x13, 0x3a, 0x75, 0x44, 0xcf, 0x70, 0xe0, 0x11, 0x03, 0xba, - 0x0b, 0x59, 0x61, 0x9a, 0x3e, 0x9b, 0x69, 0x02, 0x64, 0x7c, 0xa1, 0xf1, 0xfc, 0x3e, 0xc7, 0x8f, - 0x96, 0x93, 0xf7, 0x4e, 0xae, 0xdd, 0x62, 0xf2, 0x4e, 0x79, 0x07, 0xb4, 0x70, 0xb6, 0x5c, 0xd5, - 0x42, 0x0e, 0x7a, 0x32, 0x5b, 0x7e, 0x6a, 0x4f, 0x8c, 0x01, 0xe4, 0x31, 0x8d, 0x69, 0x74, 0x44, - 0x63, 0xf4, 0x5d, 0xd0, 0xa3, 0x19, 0xaf, 0x98, 0x1e, 0x55, 0x05, 0x6c, 0xc6, 0x9b, 0xa5, 0x47, - 0xa6, 0xf1, 0x53, 0x1d, 0xf2, 0x1d, 0x35, 0x52, 0x7d, 0x00, 0x99, 0xb0, 0xeb, 0xca, 0x67, 0xbf, - 0x3d, 0x85, 0x5b, 0x87, 0xc1, 0xe1, 0x38, 0x3e, 0xfd, 0xfa, 0x81, 0x6f, 0x53, 0x39, 0x81, 0x26, - 0x0b, 0x74, 0x4f, 0xd4, 0x31, 0x46, 0xa7, 0xe9, 0xf8, 0x4a, 0x13, 0xf1, 0xf2, 0x83, 0x13, 0x1c, - 0xbf, 0xb6, 0x91, 0x74, 0xce, 0x34, 0x9f, 0x4c, 0x94, 0x23, 0xf1, 0x10, 0x85, 0x0c, 0x3e, 0xe3, - 0x07, 0x31, 0xb5, 0x02, 0xdf, 0xe2, 0xd7, 0x47, 0xdc, 0xdc, 0x3c, 0x2e, 0x8a, 0xcd, 0x5d, 0x7f, - 0xcb, 0xf5, 0x3c, 0xa3, 0x0e, 0xa0, 0x9e, 0xde, 0x72, 0xb8, 0x29, 0xae, 0xef, 0xcb, 0x0f, 0x19, - 0x25, 0x9c, 0x2c, 0xd0, 0x75, 0x28, 0x12, 0x8f, 0x59, 0x07, 0xd4, 0xee, 0xde, 0x31, 0x7b, 0xc2, - 0xcc, 0x02, 0x06, 0xe2, 0xb1, 0x5a, 0xb2, 0x63, 0x7c, 0xa9, 0xc3, 0xe2, 0x29, 0x1b, 0xd0, 0xf7, - 0x94, 0xf5, 0x9c, 0x68, 0xc9, 0xbc, 0x3b, 0xb5, 0xf5, 0xa7, 0x57, 0x4d, 0xbf, 0xdf, 0x93, 0xfe, - 0x30, 0x7e, 0xaf, 0xc1, 0xb5, 0x73, 0x87, 0xe8, 0x5b, 0x70, 0xbd, 0xb3, 0xbb, 0xd7, 0xda, 0x6f, - 0xed, 0xb6, 0xad, 0xbd, 0xfd, 0xcd, 0xfd, 0xa6, 0xd5, 0x6c, 0x7f, 0xb6, 0x63, 0x7d, 0xd6, 0xde, - 0xeb, 0x34, 0xeb, 0xad, 0xad, 0x56, 0xb3, 0xb1, 0x3c, 0x87, 0xd6, 0xa0, 0x3c, 0x4e, 0x68, 0xb7, - 0xd3, 0x6c, 0x37, 0x1b, 0xcb, 0xda, 0x45, 0xe7, 0xf5, 0x4f, 0x77, 0xf7, 0x9a, 0x8d, 0x65, 0x1d, - 0xbd, 0x0e, 0xaf, 0x8d, 0x3b, 0x7f, 0xd8, 0xda, 0xdf, 0x6e, 0xe0, 0xcd, 0x87, 0xed, 0xe5, 0x0c, - 0xba, 0x0e, 0xdf, 0x1c, 0x4f, 0xb1, 0xd9, 0xda, 0x69, 0x36, 0x96, 0xb3, 0xfc, 0xfe, 0xcd, 0x7f, - 0x1a, 0xb6, 0x0f, 0x19, 0xba, 0x0f, 0x45, 0x35, 0xcd, 0x5b, 0xae, 0x73, 0x41, 0x9f, 0x1b, 0xeb, - 0xa1, 0x96, 0x83, 0x21, 0x1c, 0x45, 0x6b, 0x98, 0x62, 0xfa, 0xe5, 0x52, 0xcc, 0xe8, 0x40, 0x49, - 0xed, 0xef, 0x86, 0xd4, 0xe7, 0x29, 0x37, 0x7c, 0xef, 0xd0, 0x26, 0xa7, 0x9c, 0xc2, 0x8e, 0xde, - 0x4e, 0x8c, 0xef, 0x8f, 0x12, 0xa1, 0xce, 0xb3, 0xec, 0xca, 0x8c, 0x35, 0xfe, 0xa8, 0xc1, 0xb2, - 0x3a, 0x7a, 0xe8, 0xb2, 0xae, 0x13, 0x91, 0xe3, 0xab, 0x73, 0x25, 0x81, 0x15, 0x75, 0x6d, 0xd2, - 0xdf, 0x56, 0xf4, 0x4b, 0x7e, 0x5b, 0x41, 0x8a, 0x6c, 0xb4, 0x67, 0xfc, 0x49, 0x83, 0x95, 0xa1, - 0xc7, 0xe8, 0x31, 0x89, 0x9c, 0x64, 0x0a, 0xbd, 0x32, 0x1b, 0x2c, 0x40, 0x91, 0xe0, 0xbd, 0x12, - 0x13, 0xae, 0x49, 0xae, 0x94, 0x05, 0xbf, 0x92, 0xaf, 0xbe, 0xcd, 0x01, 0xb5, 0xfb, 0xa2, 0x72, - 0xde, 0x87, 0x1c, 0x8b, 0x88, 0x4d, 0xe3, 0x55, 0xed, 0x46, 0x66, 0x52, 0x77, 0x3b, 0x05, 0xe5, - 0xa5, 0xd4, 0xa6, 0x58, 0xc2, 0xd1, 0x06, 0x2f, 0x3c, 0x61, 0x5f, 0xa9, 0x7b, 0x73, 0x82, 0xba, - 0x0f, 0x88, 0xd7, 0xa7, 0x38, 0x81, 0xa0, 0xf7, 0x21, 0x97, 0x4c, 0xd2, 0xb2, 0xd4, 0x4e, 0x07, - 0x96, 0x98, 0x72, 0x1d, 0xe6, 0x85, 0x2a, 0x5c, 0x85, 0x23, 0x7e, 0x22, 0x4d, 0x99, 0x52, 0x05, - 0x01, 0x31, 0xfe, 0xae, 0xc1, 0xab, 0x67, 0x93, 0x53, 0x7c, 0x1b, 0x48, 0x17, 0x71, 0xed, 0x52, - 0x45, 0xfc, 0x4c, 0x7a, 0xe8, 0x97, 0x4e, 0x0f, 0x35, 0x3d, 0x64, 0x2e, 0x33, 0x3d, 0xfc, 0x00, - 0xbe, 0x31, 0x26, 0x77, 0xaf, 0xc6, 0xc4, 0xda, 0x97, 0xfa, 0x9f, 0x9f, 0xad, 0x69, 0x4f, 0x9f, - 0xad, 0x69, 0xff, 0x78, 0xb6, 0xa6, 0xfd, 0xf2, 0xf9, 0xda, 0xdc, 0xd3, 0xe7, 0x6b, 0x73, 0x7f, - 0x7b, 0xbe, 0x36, 0x07, 0x6b, 0x76, 0xd0, 0x7b, 0x01, 0x5b, 0x2d, 0xdf, 0xa0, 0x83, 0x4e, 0x14, - 0xb0, 0xa0, 0xa3, 0x7d, 0x8e, 0x1f, 0xbb, 0xac, 0xdb, 0x3f, 0xa8, 0xd8, 0x41, 0x6f, 0xdd, 0x0e, - 0xe2, 0x5e, 0x10, 0xaf, 0x47, 0xd4, 0x23, 0x27, 0x34, 0x5a, 0x3f, 0x32, 0x87, 0x3f, 0xed, 0x2e, - 0x71, 0xfd, 0x78, 0xfd, 0xe2, 0x3f, 0x51, 0xee, 0x3a, 0x74, 0xa0, 0x7e, 0xff, 0x56, 0xcf, 0x74, - 0xea, 0x8d, 0xdf, 0xe9, 0xe5, 0x8e, 0x52, 0xa1, 0xce, 0x55, 0x68, 0xd0, 0x41, 0xe5, 0x81, 0x14, - 0xf9, 0x6a, 0x74, 0xf8, 0x88, 0x1f, 0x3e, 0x6a, 0xd0, 0xc1, 0x23, 0x75, 0xf8, 0x4c, 0x7f, 0xe3, - 0xe2, 0xc3, 0x47, 0xf7, 0x3b, 0xb5, 0x1d, 0xca, 0x88, 0x43, 0x18, 0xf9, 0x97, 0xfe, 0x9a, 0x12, - 0xdc, 0xd8, 0xe0, 0x92, 0x1b, 0x1b, 0x0d, 0x3a, 0xd8, 0xd8, 0x50, 0xb2, 0x07, 0x39, 0xf1, 0x77, - 0xcc, 0x9d, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x37, 0xdb, 0x43, 0xeb, 0xfe, 0x19, 0x00, 0x00, -} - -func (m *Swap) 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 *Swap) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Body != nil { - { - size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.Proof != nil { - { - size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapClaim) 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 *SwapClaim) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.EpochDuration != 0 { - i = encodeVarintDex(dAtA, i, uint64(m.EpochDuration)) - i-- - dAtA[i] = 0x38 - } - if m.Body != nil { - { - size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if len(m.Proof) > 0 { - i -= len(m.Proof) - copy(dAtA[i:], m.Proof) - i = encodeVarintDex(dAtA, i, uint64(len(m.Proof))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapClaimBody) 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 *SwapClaimBody) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapClaimBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.OutputData != nil { - { - size, err := m.OutputData.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - if m.Output_2Commitment != nil { - { - size, err := m.Output_2Commitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.Output_1Commitment != nil { - { - size, err := m.Output_1Commitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Fee != nil { - { - size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Nullifier != nil { - { - size, err := m.Nullifier.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapBody) 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 *SwapBody) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Payload != nil { - { - size, err := m.Payload.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - if m.FeeCommitment != nil { - { - size, err := m.FeeCommitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.Delta_2I != nil { - { - size, err := m.Delta_2I.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Delta_1I != nil { - { - size, err := m.Delta_1I.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.TradingPair != nil { - { - size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapPayload) 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 *SwapPayload) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapPayload) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.EncryptedSwap) > 0 { - i -= len(m.EncryptedSwap) - copy(dAtA[i:], m.EncryptedSwap) - i = encodeVarintDex(dAtA, i, uint64(len(m.EncryptedSwap))) - i-- - dAtA[i] = 0x12 - } - if m.Commitment != nil { - { - size, err := m.Commitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapPlaintext) 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 *SwapPlaintext) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapPlaintext) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Rseed) > 0 { - i -= len(m.Rseed) - copy(dAtA[i:], m.Rseed) - i = encodeVarintDex(dAtA, i, uint64(len(m.Rseed))) - i-- - dAtA[i] = 0x32 - } - if m.ClaimAddress != nil { - { - size, err := m.ClaimAddress.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - if m.ClaimFee != nil { - { - size, err := m.ClaimFee.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.Delta_2I != nil { - { - size, err := m.Delta_2I.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Delta_1I != nil { - { - size, err := m.Delta_1I.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.TradingPair != nil { - { - size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapPlan) 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 *SwapPlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ProofBlindingS) > 0 { - i -= len(m.ProofBlindingS) - copy(dAtA[i:], m.ProofBlindingS) - i = encodeVarintDex(dAtA, i, uint64(len(m.ProofBlindingS))) - i-- - dAtA[i] = 0x22 - } - if len(m.ProofBlindingR) > 0 { - i -= len(m.ProofBlindingR) - copy(dAtA[i:], m.ProofBlindingR) - i = encodeVarintDex(dAtA, i, uint64(len(m.ProofBlindingR))) - i-- - dAtA[i] = 0x1a - } - if len(m.FeeBlinding) > 0 { - i -= len(m.FeeBlinding) - copy(dAtA[i:], m.FeeBlinding) - i = encodeVarintDex(dAtA, i, uint64(len(m.FeeBlinding))) - i-- - dAtA[i] = 0x12 - } - if m.SwapPlaintext != nil { - { - size, err := m.SwapPlaintext.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapClaimPlan) 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 *SwapClaimPlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ProofBlindingS) > 0 { - i -= len(m.ProofBlindingS) - copy(dAtA[i:], m.ProofBlindingS) - i = encodeVarintDex(dAtA, i, uint64(len(m.ProofBlindingS))) - i-- - dAtA[i] = 0x32 - } - if len(m.ProofBlindingR) > 0 { - i -= len(m.ProofBlindingR) - copy(dAtA[i:], m.ProofBlindingR) - i = encodeVarintDex(dAtA, i, uint64(len(m.ProofBlindingR))) - i-- - dAtA[i] = 0x2a - } - if m.EpochDuration != 0 { - i = encodeVarintDex(dAtA, i, uint64(m.EpochDuration)) - i-- - dAtA[i] = 0x20 - } - if m.OutputData != nil { - { - size, err := m.OutputData.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Position != 0 { - i = encodeVarintDex(dAtA, i, uint64(m.Position)) - i-- - dAtA[i] = 0x10 - } - if m.SwapPlaintext != nil { - { - size, err := m.SwapPlaintext.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapView) 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 *SwapView) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapView) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.SwapView != nil { - { - size := m.SwapView.Size() - i -= size - if _, err := m.SwapView.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *SwapView_Visible_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Visible != nil { - { - size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *SwapView_Opaque_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Opaque != nil { - { - size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *SwapView_Visible) 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 *SwapView_Visible) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.SwapPlaintext != nil { - { - size, err := m.SwapPlaintext.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Swap != nil { - { - size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapView_Opaque) 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 *SwapView_Opaque) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Swap != nil { - { - size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapClaimView) 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 *SwapClaimView) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapClaimView) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.SwapClaimView != nil { - { - size := m.SwapClaimView.Size() - i -= size - if _, err := m.SwapClaimView.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *SwapClaimView_Visible_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapClaimView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Visible != nil { - { - size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *SwapClaimView_Opaque_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapClaimView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Opaque != nil { - { - size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *SwapClaimView_Visible) 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 *SwapClaimView_Visible) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapClaimView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Output_2 != nil { - { - size, err := m.Output_2.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Output_1 != nil { - { - size, err := m.Output_1.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.SwapClaim != nil { - { - size, err := m.SwapClaim.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapClaimView_Opaque) 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 *SwapClaimView_Opaque) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapClaimView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.SwapClaim != nil { - { - size, err := m.SwapClaim.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *TradingPair) 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 *TradingPair) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TradingPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Asset_2 != nil { - { - size, err := m.Asset_2.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Asset_1 != nil { - { - size, err := m.Asset_1.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *DirectedTradingPair) 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 *DirectedTradingPair) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DirectedTradingPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.End != nil { - { - size, err := m.End.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Start != nil { - { - size, err := m.Start.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *BatchSwapOutputData) 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 *BatchSwapOutputData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *BatchSwapOutputData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.EpochStartingHeight != 0 { - i = encodeVarintDex(dAtA, i, uint64(m.EpochStartingHeight)) - i-- - dAtA[i] = 0x48 - } - if m.TradingPair != nil { - { - size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x42 - } - if m.Height != 0 { - i = encodeVarintDex(dAtA, i, uint64(m.Height)) - i-- - dAtA[i] = 0x38 - } - if m.Unfilled_2 != nil { - { - size, err := m.Unfilled_2.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - if m.Unfilled_1 != nil { - { - size, err := m.Unfilled_1.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - if m.Lambda_2 != nil { - { - size, err := m.Lambda_2.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.Lambda_1 != nil { - { - size, err := m.Lambda_1.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Delta_2 != nil { - { - size, err := m.Delta_2.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Delta_1 != nil { - { - size, err := m.Delta_1.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *TradingFunction) 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 *TradingFunction) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TradingFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Pair != nil { - { - size, err := m.Pair.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Component != nil { - { - size, err := m.Component.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *BareTradingFunction) 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 *BareTradingFunction) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *BareTradingFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Q != nil { - { - size, err := m.Q.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.P != nil { - { - size, err := m.P.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Fee != 0 { - i = encodeVarintDex(dAtA, i, uint64(m.Fee)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *Reserves) 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 *Reserves) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Reserves) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.R2 != nil { - { - size, err := m.R2.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.R1 != nil { - { - size, err := m.R1.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Position) 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 *Position) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Position) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.CloseOnFill { - i-- - if m.CloseOnFill { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x28 - } - if m.Reserves != nil { - { - size, err := m.Reserves.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.State != nil { - { - size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if len(m.Nonce) > 0 { - i -= len(m.Nonce) - copy(dAtA[i:], m.Nonce) - i = encodeVarintDex(dAtA, i, uint64(len(m.Nonce))) - i-- - dAtA[i] = 0x12 - } - if m.Phi != nil { - { - size, err := m.Phi.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *PositionId) 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 *PositionId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PositionId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.AltBech32M) > 0 { - i -= len(m.AltBech32M) - copy(dAtA[i:], m.AltBech32M) - i = encodeVarintDex(dAtA, i, uint64(len(m.AltBech32M))) - i-- - dAtA[i] = 0x12 - } - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintDex(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *PositionState) 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 *PositionState) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PositionState) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.State != 0 { - i = encodeVarintDex(dAtA, i, uint64(m.State)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *LpNft) 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 *LpNft) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *LpNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.State != nil { - { - size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.PositionId != nil { - { - size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *PositionOpen) 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 *PositionOpen) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Position != nil { - { - size, err := m.Position.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *PositionClose) 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 *PositionClose) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.PositionId != nil { - { - size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *PositionWithdraw) 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 *PositionWithdraw) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.ReservesCommitment != nil { - { - size, err := m.ReservesCommitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.PositionId != nil { - { - size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *PositionRewardClaim) 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 *PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.RewardsCommitment != nil { - { - size, err := m.RewardsCommitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.PositionId != nil { - { - size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SwapExecution) 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 *SwapExecution) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Output != nil { - { - size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Input != nil { - { - size, err := m.Input.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if len(m.Traces) > 0 { - for iNdEx := len(m.Traces) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Traces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil -} - -func (m *SwapExecution_Trace) 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 *SwapExecution_Trace) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapExecution_Trace) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Value) > 0 { - for iNdEx := len(m.Value) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Value[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil -} - -func (m *PositionWithdrawPlan) 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 *PositionWithdrawPlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PositionWithdrawPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Pair != nil { - { - size, err := m.Pair.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.PositionId != nil { - { - size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Reserves != nil { - { - size, err := m.Reserves.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *PositionRewardClaimPlan) 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 *PositionRewardClaimPlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PositionRewardClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Reserves != nil { - { - size, err := m.Reserves.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDex(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func encodeVarintDex(dAtA []byte, offset int, v uint64) int { - offset -= sovDex(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *Swap) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Proof != nil { - l = m.Proof.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Body != nil { - l = m.Body.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Proof) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - if m.Body != nil { - l = m.Body.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.EpochDuration != 0 { - n += 1 + sovDex(uint64(m.EpochDuration)) - } - return n -} - -func (m *SwapClaimBody) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Nullifier != nil { - l = m.Nullifier.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Fee != nil { - l = m.Fee.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Output_1Commitment != nil { - l = m.Output_1Commitment.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Output_2Commitment != nil { - l = m.Output_2Commitment.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.OutputData != nil { - l = m.OutputData.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapBody) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.TradingPair != nil { - l = m.TradingPair.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Delta_1I != nil { - l = m.Delta_1I.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Delta_2I != nil { - l = m.Delta_2I.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.FeeCommitment != nil { - l = m.FeeCommitment.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Payload != nil { - l = m.Payload.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapPayload) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Commitment != nil { - l = m.Commitment.Size() - n += 1 + l + sovDex(uint64(l)) - } - l = len(m.EncryptedSwap) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapPlaintext) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.TradingPair != nil { - l = m.TradingPair.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Delta_1I != nil { - l = m.Delta_1I.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Delta_2I != nil { - l = m.Delta_2I.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.ClaimFee != nil { - l = m.ClaimFee.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.ClaimAddress != nil { - l = m.ClaimAddress.Size() - n += 1 + l + sovDex(uint64(l)) - } - l = len(m.Rseed) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapPlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapPlaintext != nil { - l = m.SwapPlaintext.Size() - n += 1 + l + sovDex(uint64(l)) - } - l = len(m.FeeBlinding) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - l = len(m.ProofBlindingR) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - l = len(m.ProofBlindingS) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapClaimPlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapPlaintext != nil { - l = m.SwapPlaintext.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Position != 0 { - n += 1 + sovDex(uint64(m.Position)) - } - if m.OutputData != nil { - l = m.OutputData.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.EpochDuration != 0 { - n += 1 + sovDex(uint64(m.EpochDuration)) - } - l = len(m.ProofBlindingR) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - l = len(m.ProofBlindingS) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapView != nil { - n += m.SwapView.Size() - } - return n -} - -func (m *SwapView_Visible_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Visible != nil { - l = m.Visible.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} -func (m *SwapView_Opaque_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Opaque != nil { - l = m.Opaque.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} -func (m *SwapView_Visible) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Swap != nil { - l = m.Swap.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.SwapPlaintext != nil { - l = m.SwapPlaintext.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapView_Opaque) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Swap != nil { - l = m.Swap.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapClaimView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapClaimView != nil { - n += m.SwapClaimView.Size() - } - return n -} - -func (m *SwapClaimView_Visible_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Visible != nil { - l = m.Visible.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} -func (m *SwapClaimView_Opaque_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Opaque != nil { - l = m.Opaque.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} -func (m *SwapClaimView_Visible) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapClaim != nil { - l = m.SwapClaim.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Output_1 != nil { - l = m.Output_1.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Output_2 != nil { - l = m.Output_2.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapClaimView_Opaque) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapClaim != nil { - l = m.SwapClaim.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *TradingPair) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Asset_1 != nil { - l = m.Asset_1.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Asset_2 != nil { - l = m.Asset_2.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *DirectedTradingPair) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Start != nil { - l = m.Start.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.End != nil { - l = m.End.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *BatchSwapOutputData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Delta_1 != nil { - l = m.Delta_1.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Delta_2 != nil { - l = m.Delta_2.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Lambda_1 != nil { - l = m.Lambda_1.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Lambda_2 != nil { - l = m.Lambda_2.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Unfilled_1 != nil { - l = m.Unfilled_1.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Unfilled_2 != nil { - l = m.Unfilled_2.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Height != 0 { - n += 1 + sovDex(uint64(m.Height)) - } - if m.TradingPair != nil { - l = m.TradingPair.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.EpochStartingHeight != 0 { - n += 1 + sovDex(uint64(m.EpochStartingHeight)) - } - return n -} - -func (m *TradingFunction) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Component != nil { - l = m.Component.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Pair != nil { - l = m.Pair.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *BareTradingFunction) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Fee != 0 { - n += 1 + sovDex(uint64(m.Fee)) - } - if m.P != nil { - l = m.P.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Q != nil { - l = m.Q.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *Reserves) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.R1 != nil { - l = m.R1.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.R2 != nil { - l = m.R2.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *Position) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Phi != nil { - l = m.Phi.Size() - n += 1 + l + sovDex(uint64(l)) - } - l = len(m.Nonce) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - if m.State != nil { - l = m.State.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Reserves != nil { - l = m.Reserves.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.CloseOnFill { - n += 2 - } - return n -} - -func (m *PositionId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - l = len(m.AltBech32M) - if l > 0 { - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *PositionState) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.State != 0 { - n += 1 + sovDex(uint64(m.State)) - } - return n -} - -func (m *LpNft) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionId != nil { - l = m.PositionId.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.State != nil { - l = m.State.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *PositionOpen) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Position != nil { - l = m.Position.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *PositionClose) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionId != nil { - l = m.PositionId.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *PositionWithdraw) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionId != nil { - l = m.PositionId.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.ReservesCommitment != nil { - l = m.ReservesCommitment.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *PositionRewardClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionId != nil { - l = m.PositionId.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.RewardsCommitment != nil { - l = m.RewardsCommitment.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapExecution) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Traces) > 0 { - for _, e := range m.Traces { - l = e.Size() - n += 1 + l + sovDex(uint64(l)) - } - } - if m.Input != nil { - l = m.Input.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Output != nil { - l = m.Output.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *SwapExecution_Trace) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Value) > 0 { - for _, e := range m.Value { - l = e.Size() - n += 1 + l + sovDex(uint64(l)) - } - } - return n -} - -func (m *PositionWithdrawPlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Reserves != nil { - l = m.Reserves.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.PositionId != nil { - l = m.PositionId.Size() - n += 1 + l + sovDex(uint64(l)) - } - if m.Pair != nil { - l = m.Pair.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func (m *PositionRewardClaimPlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Reserves != nil { - l = m.Reserves.Size() - n += 1 + l + sovDex(uint64(l)) - } - return n -} - -func sovDex(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozDex(x uint64) (n int) { - return sovDex(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *Swap) 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 ErrIntOverflowDex - } - 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: Swap: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Swap: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Proof == nil { - m.Proof = &v1alpha1.ZKSwapProof{} - } - if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Body == nil { - m.Body = &SwapBody{} - } - if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapClaim) 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 ErrIntOverflowDex - } - 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: SwapClaim: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapClaim: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...) - if m.Proof == nil { - m.Proof = []byte{} - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Body == nil { - m.Body = &SwapClaimBody{} - } - if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EpochDuration", wireType) - } - m.EpochDuration = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.EpochDuration |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapClaimBody) 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 ErrIntOverflowDex - } - 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: SwapClaimBody: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapClaimBody: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Nullifier == nil { - m.Nullifier = &v1alpha1.Nullifier{} - } - if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Fee == nil { - m.Fee = &v1alpha1.Fee{} - } - if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Output_1Commitment", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Output_1Commitment == nil { - m.Output_1Commitment = &v1alpha1.StateCommitment{} - } - if err := m.Output_1Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Output_2Commitment", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Output_2Commitment == nil { - m.Output_2Commitment = &v1alpha1.StateCommitment{} - } - if err := m.Output_2Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field OutputData", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.OutputData == nil { - m.OutputData = &BatchSwapOutputData{} - } - if err := m.OutputData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapBody) 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 ErrIntOverflowDex - } - 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: SwapBody: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapBody: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.TradingPair == nil { - m.TradingPair = &TradingPair{} - } - if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Delta_1I", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Delta_1I == nil { - m.Delta_1I = &v1alpha1.Amount{} - } - if err := m.Delta_1I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Delta_2I", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Delta_2I == nil { - m.Delta_2I = &v1alpha1.Amount{} - } - if err := m.Delta_2I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FeeCommitment", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.FeeCommitment == nil { - m.FeeCommitment = &v1alpha1.BalanceCommitment{} - } - if err := m.FeeCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Payload == nil { - m.Payload = &SwapPayload{} - } - if err := m.Payload.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapPayload) 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 ErrIntOverflowDex - } - 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: SwapPayload: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapPayload: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Commitment", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Commitment == nil { - m.Commitment = &v1alpha1.StateCommitment{} - } - if err := m.Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EncryptedSwap", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.EncryptedSwap = append(m.EncryptedSwap[:0], dAtA[iNdEx:postIndex]...) - if m.EncryptedSwap == nil { - m.EncryptedSwap = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapPlaintext) 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 ErrIntOverflowDex - } - 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: SwapPlaintext: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapPlaintext: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.TradingPair == nil { - m.TradingPair = &TradingPair{} - } - if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Delta_1I", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Delta_1I == nil { - m.Delta_1I = &v1alpha1.Amount{} - } - if err := m.Delta_1I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Delta_2I", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Delta_2I == nil { - m.Delta_2I = &v1alpha1.Amount{} - } - if err := m.Delta_2I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClaimFee", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ClaimFee == nil { - m.ClaimFee = &v1alpha1.Fee{} - } - if err := m.ClaimFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClaimAddress", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ClaimAddress == nil { - m.ClaimAddress = &v1alpha1.Address{} - } - if err := m.ClaimAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) - if m.Rseed == nil { - m.Rseed = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapPlan) 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 ErrIntOverflowDex - } - 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: SwapPlan: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapPlan: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapPlaintext", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.SwapPlaintext == nil { - m.SwapPlaintext = &SwapPlaintext{} - } - if err := m.SwapPlaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FeeBlinding", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.FeeBlinding = append(m.FeeBlinding[:0], dAtA[iNdEx:postIndex]...) - if m.FeeBlinding == nil { - m.FeeBlinding = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingR == nil { - m.ProofBlindingR = []byte{} - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingS == nil { - m.ProofBlindingS = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapClaimPlan) 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 ErrIntOverflowDex - } - 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: SwapClaimPlan: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapClaimPlan: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapPlaintext", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.SwapPlaintext == nil { - m.SwapPlaintext = &SwapPlaintext{} - } - if err := m.SwapPlaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) - } - m.Position = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Position |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field OutputData", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.OutputData == nil { - m.OutputData = &BatchSwapOutputData{} - } - if err := m.OutputData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EpochDuration", wireType) - } - m.EpochDuration = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.EpochDuration |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingR == nil { - m.ProofBlindingR = []byte{} - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingS == nil { - m.ProofBlindingS = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapView) 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 ErrIntOverflowDex - } - 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: SwapView: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapView: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &SwapView_Visible{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.SwapView = &SwapView_Visible_{v} - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &SwapView_Opaque{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.SwapView = &SwapView_Opaque_{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapView_Visible) 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 ErrIntOverflowDex - } - 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: Visible: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Swap == nil { - m.Swap = &Swap{} - } - if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapPlaintext", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.SwapPlaintext == nil { - m.SwapPlaintext = &SwapPlaintext{} - } - if err := m.SwapPlaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapView_Opaque) 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 ErrIntOverflowDex - } - 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: Opaque: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Swap == nil { - m.Swap = &Swap{} - } - if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapClaimView) 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 ErrIntOverflowDex - } - 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: SwapClaimView: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapClaimView: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &SwapClaimView_Visible{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.SwapClaimView = &SwapClaimView_Visible_{v} - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &SwapClaimView_Opaque{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.SwapClaimView = &SwapClaimView_Opaque_{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapClaimView_Visible) 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 ErrIntOverflowDex - } - 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: Visible: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.SwapClaim == nil { - m.SwapClaim = &SwapClaim{} - } - if err := m.SwapClaim.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Output_1", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Output_1 == nil { - m.Output_1 = &v1alpha1.NoteView{} - } - if err := m.Output_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Output_2", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Output_2 == nil { - m.Output_2 = &v1alpha1.NoteView{} - } - if err := m.Output_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapClaimView_Opaque) 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 ErrIntOverflowDex - } - 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: Opaque: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.SwapClaim == nil { - m.SwapClaim = &SwapClaim{} - } - if err := m.SwapClaim.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TradingPair) 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 ErrIntOverflowDex - } - 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: TradingPair: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TradingPair: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Asset_1", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Asset_1 == nil { - m.Asset_1 = &v1alpha1.AssetId{} - } - if err := m.Asset_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Asset_2", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Asset_2 == nil { - m.Asset_2 = &v1alpha1.AssetId{} - } - if err := m.Asset_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DirectedTradingPair) 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 ErrIntOverflowDex - } - 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: DirectedTradingPair: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DirectedTradingPair: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Start == nil { - m.Start = &v1alpha1.AssetId{} - } - if err := m.Start.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field End", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.End == nil { - m.End = &v1alpha1.AssetId{} - } - if err := m.End.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *BatchSwapOutputData) 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 ErrIntOverflowDex - } - 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: BatchSwapOutputData: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: BatchSwapOutputData: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Delta_1", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Delta_1 == nil { - m.Delta_1 = &v1alpha1.Amount{} - } - if err := m.Delta_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Delta_2", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Delta_2 == nil { - m.Delta_2 = &v1alpha1.Amount{} - } - if err := m.Delta_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Lambda_1", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Lambda_1 == nil { - m.Lambda_1 = &v1alpha1.Amount{} - } - if err := m.Lambda_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Lambda_2", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Lambda_2 == nil { - m.Lambda_2 = &v1alpha1.Amount{} - } - if err := m.Lambda_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Unfilled_1", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Unfilled_1 == nil { - m.Unfilled_1 = &v1alpha1.Amount{} - } - if err := m.Unfilled_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Unfilled_2", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Unfilled_2 == nil { - m.Unfilled_2 = &v1alpha1.Amount{} - } - if err := m.Unfilled_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) - } - m.Height = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Height |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.TradingPair == nil { - m.TradingPair = &TradingPair{} - } - if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 9: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EpochStartingHeight", wireType) - } - m.EpochStartingHeight = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.EpochStartingHeight |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TradingFunction) 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 ErrIntOverflowDex - } - 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: TradingFunction: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TradingFunction: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Component", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Component == nil { - m.Component = &BareTradingFunction{} - } - if err := m.Component.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Pair", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Pair == nil { - m.Pair = &TradingPair{} - } - if err := m.Pair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *BareTradingFunction) 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 ErrIntOverflowDex - } - 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: BareTradingFunction: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: BareTradingFunction: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) - } - m.Fee = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Fee |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field P", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.P == nil { - m.P = &v1alpha1.Amount{} - } - if err := m.P.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Q", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Q == nil { - m.Q = &v1alpha1.Amount{} - } - if err := m.Q.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Reserves) 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 ErrIntOverflowDex - } - 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: Reserves: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Reserves: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field R1", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.R1 == nil { - m.R1 = &v1alpha1.Amount{} - } - if err := m.R1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field R2", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.R2 == nil { - m.R2 = &v1alpha1.Amount{} - } - if err := m.R2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Position) 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 ErrIntOverflowDex - } - 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: Position: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Position: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Phi", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Phi == nil { - m.Phi = &TradingFunction{} - } - if err := m.Phi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Nonce = append(m.Nonce[:0], dAtA[iNdEx:postIndex]...) - if m.Nonce == nil { - m.Nonce = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.State == nil { - m.State = &PositionState{} - } - if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reserves", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Reserves == nil { - m.Reserves = &Reserves{} - } - if err := m.Reserves.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CloseOnFill", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.CloseOnFill = bool(v != 0) - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PositionId) 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 ErrIntOverflowDex - } - 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: PositionId: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PositionId: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AltBech32M", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - 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 ErrInvalidLengthDex - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.AltBech32M = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PositionState) 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 ErrIntOverflowDex - } - 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: PositionState: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PositionState: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) - } - m.State = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.State |= PositionState_PositionStateEnum(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *LpNft) 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 ErrIntOverflowDex - } - 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: LpNft: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LpNft: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.PositionId == nil { - m.PositionId = &PositionId{} - } - if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.State == nil { - m.State = &PositionState{} - } - if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PositionOpen) 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 ErrIntOverflowDex - } - 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: PositionOpen: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PositionOpen: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Position == nil { - m.Position = &Position{} - } - if err := m.Position.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PositionClose) 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 ErrIntOverflowDex - } - 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: PositionClose: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PositionClose: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.PositionId == nil { - m.PositionId = &PositionId{} - } - if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PositionWithdraw) 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 ErrIntOverflowDex - } - 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: PositionWithdraw: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PositionWithdraw: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.PositionId == nil { - m.PositionId = &PositionId{} - } - if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReservesCommitment", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ReservesCommitment == nil { - m.ReservesCommitment = &v1alpha1.BalanceCommitment{} - } - if err := m.ReservesCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PositionRewardClaim) 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 ErrIntOverflowDex - } - 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: PositionRewardClaim: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PositionRewardClaim: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.PositionId == nil { - m.PositionId = &PositionId{} - } - if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RewardsCommitment", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.RewardsCommitment == nil { - m.RewardsCommitment = &v1alpha1.BalanceCommitment{} - } - if err := m.RewardsCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapExecution) 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 ErrIntOverflowDex - } - 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: SwapExecution: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapExecution: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Traces", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Traces = append(m.Traces, &SwapExecution_Trace{}) - if err := m.Traces[len(m.Traces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Input == nil { - m.Input = &v1alpha1.Value{} - } - if err := m.Input.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Output == nil { - m.Output = &v1alpha1.Value{} - } - if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwapExecution_Trace) 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 ErrIntOverflowDex - } - 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: Trace: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Trace: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Value = append(m.Value, &v1alpha1.Value{}) - if err := m.Value[len(m.Value)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PositionWithdrawPlan) 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 ErrIntOverflowDex - } - 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: PositionWithdrawPlan: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PositionWithdrawPlan: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reserves", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Reserves == nil { - m.Reserves = &Reserves{} - } - if err := m.Reserves.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.PositionId == nil { - m.PositionId = &PositionId{} - } - if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Pair", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Pair == nil { - m.Pair = &TradingPair{} - } - if err := m.Pair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PositionRewardClaimPlan) 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 ErrIntOverflowDex - } - 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: PositionRewardClaimPlan: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PositionRewardClaimPlan: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reserves", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDex - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDex - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthDex - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Reserves == nil { - m.Reserves = &Reserves{} - } - if err := m.Reserves.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipDex(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthDex - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipDex(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, ErrIntOverflowDex - } - 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, ErrIntOverflowDex - } - 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, ErrIntOverflowDex - } - 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, ErrInvalidLengthDex - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupDex - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthDex - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthDex = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowDex = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupDex = fmt.Errorf("proto: unexpected end of group") -) diff --git a/relayer/chains/penumbra/core/governance/v1alpha1/governance.pb.go b/relayer/chains/penumbra/core/governance/v1alpha1/governance.pb.go deleted file mode 100644 index 80977b8d4..000000000 --- a/relayer/chains/penumbra/core/governance/v1alpha1/governance.pb.go +++ /dev/null @@ -1,7343 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: penumbra/core/governance/v1alpha1/governance.proto - -package governancev1alpha1 - -import ( - fmt "fmt" - types "github.com/cosmos/cosmos-sdk/codec/types" - proto "github.com/cosmos/gogoproto/proto" - v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/chain/v1alpha1" - v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" - 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 - -// A vote. -type Vote_Vote int32 - -const ( - Vote_VOTE_UNSPECIFIED Vote_Vote = 0 - Vote_VOTE_ABSTAIN Vote_Vote = 1 - Vote_VOTE_YES Vote_Vote = 2 - Vote_VOTE_NO Vote_Vote = 3 -) - -var Vote_Vote_name = map[int32]string{ - 0: "VOTE_UNSPECIFIED", - 1: "VOTE_ABSTAIN", - 2: "VOTE_YES", - 3: "VOTE_NO", -} - -var Vote_Vote_value = map[string]int32{ - "VOTE_UNSPECIFIED": 0, - "VOTE_ABSTAIN": 1, - "VOTE_YES": 2, - "VOTE_NO": 3, -} - -func (x Vote_Vote) String() string { - return proto.EnumName(Vote_Vote_name, int32(x)) -} - -func (Vote_Vote) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{11, 0} -} - -type ProposalSubmit struct { - // The proposal to be submitted. - Proposal *Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"` - // The amount of the proposal deposit. - DepositAmount *v1alpha1.Amount `protobuf:"bytes,3,opt,name=deposit_amount,json=depositAmount,proto3" json:"deposit_amount,omitempty"` -} - -func (m *ProposalSubmit) Reset() { *m = ProposalSubmit{} } -func (m *ProposalSubmit) String() string { return proto.CompactTextString(m) } -func (*ProposalSubmit) ProtoMessage() {} -func (*ProposalSubmit) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{0} -} -func (m *ProposalSubmit) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalSubmit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalSubmit.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 *ProposalSubmit) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalSubmit.Merge(m, src) -} -func (m *ProposalSubmit) XXX_Size() int { - return m.Size() -} -func (m *ProposalSubmit) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalSubmit.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalSubmit proto.InternalMessageInfo - -func (m *ProposalSubmit) GetProposal() *Proposal { - if m != nil { - return m.Proposal - } - return nil -} - -func (m *ProposalSubmit) GetDepositAmount() *v1alpha1.Amount { - if m != nil { - return m.DepositAmount - } - return nil -} - -type ProposalWithdraw struct { - // The proposal to be withdrawn. - Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` - // The reason for the proposal being withdrawn. - Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` -} - -func (m *ProposalWithdraw) Reset() { *m = ProposalWithdraw{} } -func (m *ProposalWithdraw) String() string { return proto.CompactTextString(m) } -func (*ProposalWithdraw) ProtoMessage() {} -func (*ProposalWithdraw) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{1} -} -func (m *ProposalWithdraw) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalWithdraw) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalWithdraw.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 *ProposalWithdraw) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalWithdraw.Merge(m, src) -} -func (m *ProposalWithdraw) XXX_Size() int { - return m.Size() -} -func (m *ProposalWithdraw) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalWithdraw.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalWithdraw proto.InternalMessageInfo - -func (m *ProposalWithdraw) GetProposal() uint64 { - if m != nil { - return m.Proposal - } - return 0 -} - -func (m *ProposalWithdraw) GetReason() string { - if m != nil { - return m.Reason - } - return "" -} - -type ProposalDepositClaim struct { - // The proposal to claim the deposit for. - Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` - // The expected deposit amount. - DepositAmount *v1alpha1.Amount `protobuf:"bytes,2,opt,name=deposit_amount,json=depositAmount,proto3" json:"deposit_amount,omitempty"` - // The outcome of the proposal. - Outcome *ProposalOutcome `protobuf:"bytes,3,opt,name=outcome,proto3" json:"outcome,omitempty"` -} - -func (m *ProposalDepositClaim) Reset() { *m = ProposalDepositClaim{} } -func (m *ProposalDepositClaim) String() string { return proto.CompactTextString(m) } -func (*ProposalDepositClaim) ProtoMessage() {} -func (*ProposalDepositClaim) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{2} -} -func (m *ProposalDepositClaim) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalDepositClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalDepositClaim.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 *ProposalDepositClaim) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalDepositClaim.Merge(m, src) -} -func (m *ProposalDepositClaim) XXX_Size() int { - return m.Size() -} -func (m *ProposalDepositClaim) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalDepositClaim.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalDepositClaim proto.InternalMessageInfo - -func (m *ProposalDepositClaim) GetProposal() uint64 { - if m != nil { - return m.Proposal - } - return 0 -} - -func (m *ProposalDepositClaim) GetDepositAmount() *v1alpha1.Amount { - if m != nil { - return m.DepositAmount - } - return nil -} - -func (m *ProposalDepositClaim) GetOutcome() *ProposalOutcome { - if m != nil { - return m.Outcome - } - return nil -} - -type ValidatorVote struct { - // The effecting data for the vote. - Body *ValidatorVoteBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` - // The vote authorization signature is authorizing data. - AuthSig *v1alpha1.SpendAuthSignature `protobuf:"bytes,2,opt,name=auth_sig,json=authSig,proto3" json:"auth_sig,omitempty"` -} - -func (m *ValidatorVote) Reset() { *m = ValidatorVote{} } -func (m *ValidatorVote) String() string { return proto.CompactTextString(m) } -func (*ValidatorVote) ProtoMessage() {} -func (*ValidatorVote) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{3} -} -func (m *ValidatorVote) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ValidatorVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ValidatorVote.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 *ValidatorVote) XXX_Merge(src proto.Message) { - xxx_messageInfo_ValidatorVote.Merge(m, src) -} -func (m *ValidatorVote) XXX_Size() int { - return m.Size() -} -func (m *ValidatorVote) XXX_DiscardUnknown() { - xxx_messageInfo_ValidatorVote.DiscardUnknown(m) -} - -var xxx_messageInfo_ValidatorVote proto.InternalMessageInfo - -func (m *ValidatorVote) GetBody() *ValidatorVoteBody { - if m != nil { - return m.Body - } - return nil -} - -func (m *ValidatorVote) GetAuthSig() *v1alpha1.SpendAuthSignature { - if m != nil { - return m.AuthSig - } - return nil -} - -type ValidatorVoteBody struct { - // The proposal being voted on. - Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` - // The vote. - Vote *Vote `protobuf:"bytes,2,opt,name=vote,proto3" json:"vote,omitempty"` - // The validator identity. - IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,3,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` - // The validator governance key. - GovernanceKey *v1alpha1.GovernanceKey `protobuf:"bytes,4,opt,name=governance_key,json=governanceKey,proto3" json:"governance_key,omitempty"` -} - -func (m *ValidatorVoteBody) Reset() { *m = ValidatorVoteBody{} } -func (m *ValidatorVoteBody) String() string { return proto.CompactTextString(m) } -func (*ValidatorVoteBody) ProtoMessage() {} -func (*ValidatorVoteBody) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{4} -} -func (m *ValidatorVoteBody) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ValidatorVoteBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ValidatorVoteBody.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 *ValidatorVoteBody) XXX_Merge(src proto.Message) { - xxx_messageInfo_ValidatorVoteBody.Merge(m, src) -} -func (m *ValidatorVoteBody) XXX_Size() int { - return m.Size() -} -func (m *ValidatorVoteBody) XXX_DiscardUnknown() { - xxx_messageInfo_ValidatorVoteBody.DiscardUnknown(m) -} - -var xxx_messageInfo_ValidatorVoteBody proto.InternalMessageInfo - -func (m *ValidatorVoteBody) GetProposal() uint64 { - if m != nil { - return m.Proposal - } - return 0 -} - -func (m *ValidatorVoteBody) GetVote() *Vote { - if m != nil { - return m.Vote - } - return nil -} - -func (m *ValidatorVoteBody) GetIdentityKey() *v1alpha1.IdentityKey { - if m != nil { - return m.IdentityKey - } - return nil -} - -func (m *ValidatorVoteBody) GetGovernanceKey() *v1alpha1.GovernanceKey { - if m != nil { - return m.GovernanceKey - } - return nil -} - -type DelegatorVote struct { - // The effecting data for the vote. - Body *DelegatorVoteBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` - // The vote authorization signature is authorizing data. - AuthSig *v1alpha1.SpendAuthSignature `protobuf:"bytes,2,opt,name=auth_sig,json=authSig,proto3" json:"auth_sig,omitempty"` - // The vote proof is authorizing data. - Proof *v1alpha1.ZKDelegatorVoteProof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"` -} - -func (m *DelegatorVote) Reset() { *m = DelegatorVote{} } -func (m *DelegatorVote) String() string { return proto.CompactTextString(m) } -func (*DelegatorVote) ProtoMessage() {} -func (*DelegatorVote) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{5} -} -func (m *DelegatorVote) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DelegatorVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DelegatorVote.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 *DelegatorVote) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelegatorVote.Merge(m, src) -} -func (m *DelegatorVote) XXX_Size() int { - return m.Size() -} -func (m *DelegatorVote) XXX_DiscardUnknown() { - xxx_messageInfo_DelegatorVote.DiscardUnknown(m) -} - -var xxx_messageInfo_DelegatorVote proto.InternalMessageInfo - -func (m *DelegatorVote) GetBody() *DelegatorVoteBody { - if m != nil { - return m.Body - } - return nil -} - -func (m *DelegatorVote) GetAuthSig() *v1alpha1.SpendAuthSignature { - if m != nil { - return m.AuthSig - } - return nil -} - -func (m *DelegatorVote) GetProof() *v1alpha1.ZKDelegatorVoteProof { - if m != nil { - return m.Proof - } - return nil -} - -type DelegatorVoteBody struct { - // The proposal being voted on. - Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` - // The start position of the proposal in the TCT. - StartPosition uint64 `protobuf:"varint,2,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"` - // The vote. - Vote *Vote `protobuf:"bytes,3,opt,name=vote,proto3" json:"vote,omitempty"` - // The value of the delegation note. - Value *v1alpha1.Value `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"` - // The amount of the delegation note, in unbonded penumbra. - UnbondedAmount *v1alpha1.Amount `protobuf:"bytes,5,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"` - // The nullifier of the input note. - Nullifier []byte `protobuf:"bytes,6,opt,name=nullifier,proto3" json:"nullifier,omitempty"` - // The randomized validating key for the spend authorization signature. - Rk []byte `protobuf:"bytes,7,opt,name=rk,proto3" json:"rk,omitempty"` -} - -func (m *DelegatorVoteBody) Reset() { *m = DelegatorVoteBody{} } -func (m *DelegatorVoteBody) String() string { return proto.CompactTextString(m) } -func (*DelegatorVoteBody) ProtoMessage() {} -func (*DelegatorVoteBody) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{6} -} -func (m *DelegatorVoteBody) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DelegatorVoteBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DelegatorVoteBody.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 *DelegatorVoteBody) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelegatorVoteBody.Merge(m, src) -} -func (m *DelegatorVoteBody) XXX_Size() int { - return m.Size() -} -func (m *DelegatorVoteBody) XXX_DiscardUnknown() { - xxx_messageInfo_DelegatorVoteBody.DiscardUnknown(m) -} - -var xxx_messageInfo_DelegatorVoteBody proto.InternalMessageInfo - -func (m *DelegatorVoteBody) GetProposal() uint64 { - if m != nil { - return m.Proposal - } - return 0 -} - -func (m *DelegatorVoteBody) GetStartPosition() uint64 { - if m != nil { - return m.StartPosition - } - return 0 -} - -func (m *DelegatorVoteBody) GetVote() *Vote { - if m != nil { - return m.Vote - } - return nil -} - -func (m *DelegatorVoteBody) GetValue() *v1alpha1.Value { - if m != nil { - return m.Value - } - return nil -} - -func (m *DelegatorVoteBody) GetUnbondedAmount() *v1alpha1.Amount { - if m != nil { - return m.UnbondedAmount - } - return nil -} - -func (m *DelegatorVoteBody) GetNullifier() []byte { - if m != nil { - return m.Nullifier - } - return nil -} - -func (m *DelegatorVoteBody) GetRk() []byte { - if m != nil { - return m.Rk - } - return nil -} - -type DelegatorVotePlan struct { - // The proposal to vote on. - Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` - // The start position of the proposal in the TCT. - StartPosition uint64 `protobuf:"varint,2,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"` - // The vote to cast. - Vote *Vote `protobuf:"bytes,3,opt,name=vote,proto3" json:"vote,omitempty"` - // The delegation note to prove that we can vote. - StakedNote *v1alpha1.Note `protobuf:"bytes,4,opt,name=staked_note,json=stakedNote,proto3" json:"staked_note,omitempty"` - // The position of that delegation note. - StakedNotePosition uint64 `protobuf:"varint,5,opt,name=staked_note_position,json=stakedNotePosition,proto3" json:"staked_note_position,omitempty"` - // The unbonded amount equivalent to the delegation note. - UnbondedAmount *v1alpha1.Amount `protobuf:"bytes,6,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"` - // The randomizer to use for the proof of spend capability. - Randomizer []byte `protobuf:"bytes,7,opt,name=randomizer,proto3" json:"randomizer,omitempty"` - // The first blinding factor to use for the ZK delegator vote proof. - ProofBlindingR []byte `protobuf:"bytes,8,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` - // The second blinding factor to use for the ZK delegator vote proof. - ProofBlindingS []byte `protobuf:"bytes,9,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` -} - -func (m *DelegatorVotePlan) Reset() { *m = DelegatorVotePlan{} } -func (m *DelegatorVotePlan) String() string { return proto.CompactTextString(m) } -func (*DelegatorVotePlan) ProtoMessage() {} -func (*DelegatorVotePlan) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{7} -} -func (m *DelegatorVotePlan) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DelegatorVotePlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DelegatorVotePlan.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 *DelegatorVotePlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelegatorVotePlan.Merge(m, src) -} -func (m *DelegatorVotePlan) XXX_Size() int { - return m.Size() -} -func (m *DelegatorVotePlan) XXX_DiscardUnknown() { - xxx_messageInfo_DelegatorVotePlan.DiscardUnknown(m) -} - -var xxx_messageInfo_DelegatorVotePlan proto.InternalMessageInfo - -func (m *DelegatorVotePlan) GetProposal() uint64 { - if m != nil { - return m.Proposal - } - return 0 -} - -func (m *DelegatorVotePlan) GetStartPosition() uint64 { - if m != nil { - return m.StartPosition - } - return 0 -} - -func (m *DelegatorVotePlan) GetVote() *Vote { - if m != nil { - return m.Vote - } - return nil -} - -func (m *DelegatorVotePlan) GetStakedNote() *v1alpha1.Note { - if m != nil { - return m.StakedNote - } - return nil -} - -func (m *DelegatorVotePlan) GetStakedNotePosition() uint64 { - if m != nil { - return m.StakedNotePosition - } - return 0 -} - -func (m *DelegatorVotePlan) GetUnbondedAmount() *v1alpha1.Amount { - if m != nil { - return m.UnbondedAmount - } - return nil -} - -func (m *DelegatorVotePlan) GetRandomizer() []byte { - if m != nil { - return m.Randomizer - } - return nil -} - -func (m *DelegatorVotePlan) GetProofBlindingR() []byte { - if m != nil { - return m.ProofBlindingR - } - return nil -} - -func (m *DelegatorVotePlan) GetProofBlindingS() []byte { - if m != nil { - return m.ProofBlindingS - } - return nil -} - -type DaoDeposit struct { - // The value to deposit into the DAO. - Value *v1alpha1.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` -} - -func (m *DaoDeposit) Reset() { *m = DaoDeposit{} } -func (m *DaoDeposit) String() string { return proto.CompactTextString(m) } -func (*DaoDeposit) ProtoMessage() {} -func (*DaoDeposit) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{8} -} -func (m *DaoDeposit) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DaoDeposit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DaoDeposit.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 *DaoDeposit) XXX_Merge(src proto.Message) { - xxx_messageInfo_DaoDeposit.Merge(m, src) -} -func (m *DaoDeposit) XXX_Size() int { - return m.Size() -} -func (m *DaoDeposit) XXX_DiscardUnknown() { - xxx_messageInfo_DaoDeposit.DiscardUnknown(m) -} - -var xxx_messageInfo_DaoDeposit proto.InternalMessageInfo - -func (m *DaoDeposit) GetValue() *v1alpha1.Value { - if m != nil { - return m.Value - } - return nil -} - -type DaoSpend struct { - // The value to spend from the DAO. - Value *v1alpha1.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` -} - -func (m *DaoSpend) Reset() { *m = DaoSpend{} } -func (m *DaoSpend) String() string { return proto.CompactTextString(m) } -func (*DaoSpend) ProtoMessage() {} -func (*DaoSpend) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{9} -} -func (m *DaoSpend) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DaoSpend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DaoSpend.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 *DaoSpend) XXX_Merge(src proto.Message) { - xxx_messageInfo_DaoSpend.Merge(m, src) -} -func (m *DaoSpend) XXX_Size() int { - return m.Size() -} -func (m *DaoSpend) XXX_DiscardUnknown() { - xxx_messageInfo_DaoSpend.DiscardUnknown(m) -} - -var xxx_messageInfo_DaoSpend proto.InternalMessageInfo - -func (m *DaoSpend) GetValue() *v1alpha1.Value { - if m != nil { - return m.Value - } - return nil -} - -type DaoOutput struct { - // The value to output from the DAO. - Value *v1alpha1.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` - // The address to send the output to. - Address *v1alpha1.Address `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` -} - -func (m *DaoOutput) Reset() { *m = DaoOutput{} } -func (m *DaoOutput) String() string { return proto.CompactTextString(m) } -func (*DaoOutput) ProtoMessage() {} -func (*DaoOutput) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{10} -} -func (m *DaoOutput) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DaoOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DaoOutput.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 *DaoOutput) XXX_Merge(src proto.Message) { - xxx_messageInfo_DaoOutput.Merge(m, src) -} -func (m *DaoOutput) XXX_Size() int { - return m.Size() -} -func (m *DaoOutput) XXX_DiscardUnknown() { - xxx_messageInfo_DaoOutput.DiscardUnknown(m) -} - -var xxx_messageInfo_DaoOutput proto.InternalMessageInfo - -func (m *DaoOutput) GetValue() *v1alpha1.Value { - if m != nil { - return m.Value - } - return nil -} - -func (m *DaoOutput) GetAddress() *v1alpha1.Address { - if m != nil { - return m.Address - } - return nil -} - -// A vote on a proposal. -type Vote struct { - // The vote. - Vote Vote_Vote `protobuf:"varint,1,opt,name=vote,proto3,enum=penumbra.core.governance.v1alpha1.Vote_Vote" json:"vote,omitempty"` -} - -func (m *Vote) Reset() { *m = Vote{} } -func (m *Vote) String() string { return proto.CompactTextString(m) } -func (*Vote) ProtoMessage() {} -func (*Vote) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{11} -} -func (m *Vote) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Vote.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 *Vote) XXX_Merge(src proto.Message) { - xxx_messageInfo_Vote.Merge(m, src) -} -func (m *Vote) XXX_Size() int { - return m.Size() -} -func (m *Vote) XXX_DiscardUnknown() { - xxx_messageInfo_Vote.DiscardUnknown(m) -} - -var xxx_messageInfo_Vote proto.InternalMessageInfo - -func (m *Vote) GetVote() Vote_Vote { - if m != nil { - return m.Vote - } - return Vote_VOTE_UNSPECIFIED -} - -// The current state of a proposal. -type ProposalState struct { - // The state of the proposal. - // - // Types that are valid to be assigned to State: - // *ProposalState_Voting_ - // *ProposalState_Withdrawn_ - // *ProposalState_Finished_ - // *ProposalState_Claimed_ - State isProposalState_State `protobuf_oneof:"state"` -} - -func (m *ProposalState) Reset() { *m = ProposalState{} } -func (m *ProposalState) String() string { return proto.CompactTextString(m) } -func (*ProposalState) ProtoMessage() {} -func (*ProposalState) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{12} -} -func (m *ProposalState) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalState.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 *ProposalState) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalState.Merge(m, src) -} -func (m *ProposalState) XXX_Size() int { - return m.Size() -} -func (m *ProposalState) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalState.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalState proto.InternalMessageInfo - -type isProposalState_State interface { - isProposalState_State() - MarshalTo([]byte) (int, error) - Size() int -} - -type ProposalState_Voting_ struct { - Voting *ProposalState_Voting `protobuf:"bytes,2,opt,name=voting,proto3,oneof" json:"voting,omitempty"` -} -type ProposalState_Withdrawn_ struct { - Withdrawn *ProposalState_Withdrawn `protobuf:"bytes,3,opt,name=withdrawn,proto3,oneof" json:"withdrawn,omitempty"` -} -type ProposalState_Finished_ struct { - Finished *ProposalState_Finished `protobuf:"bytes,4,opt,name=finished,proto3,oneof" json:"finished,omitempty"` -} -type ProposalState_Claimed_ struct { - Claimed *ProposalState_Claimed `protobuf:"bytes,5,opt,name=claimed,proto3,oneof" json:"claimed,omitempty"` -} - -func (*ProposalState_Voting_) isProposalState_State() {} -func (*ProposalState_Withdrawn_) isProposalState_State() {} -func (*ProposalState_Finished_) isProposalState_State() {} -func (*ProposalState_Claimed_) isProposalState_State() {} - -func (m *ProposalState) GetState() isProposalState_State { - if m != nil { - return m.State - } - return nil -} - -func (m *ProposalState) GetVoting() *ProposalState_Voting { - if x, ok := m.GetState().(*ProposalState_Voting_); ok { - return x.Voting - } - return nil -} - -func (m *ProposalState) GetWithdrawn() *ProposalState_Withdrawn { - if x, ok := m.GetState().(*ProposalState_Withdrawn_); ok { - return x.Withdrawn - } - return nil -} - -func (m *ProposalState) GetFinished() *ProposalState_Finished { - if x, ok := m.GetState().(*ProposalState_Finished_); ok { - return x.Finished - } - return nil -} - -func (m *ProposalState) GetClaimed() *ProposalState_Claimed { - if x, ok := m.GetState().(*ProposalState_Claimed_); ok { - return x.Claimed - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*ProposalState) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*ProposalState_Voting_)(nil), - (*ProposalState_Withdrawn_)(nil), - (*ProposalState_Finished_)(nil), - (*ProposalState_Claimed_)(nil), - } -} - -// Voting is in progress and the proposal has not yet concluded voting or been withdrawn. -type ProposalState_Voting struct { -} - -func (m *ProposalState_Voting) Reset() { *m = ProposalState_Voting{} } -func (m *ProposalState_Voting) String() string { return proto.CompactTextString(m) } -func (*ProposalState_Voting) ProtoMessage() {} -func (*ProposalState_Voting) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{12, 0} -} -func (m *ProposalState_Voting) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalState_Voting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalState_Voting.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 *ProposalState_Voting) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalState_Voting.Merge(m, src) -} -func (m *ProposalState_Voting) XXX_Size() int { - return m.Size() -} -func (m *ProposalState_Voting) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalState_Voting.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalState_Voting proto.InternalMessageInfo - -// The proposal has been withdrawn but the voting period is not yet concluded. -type ProposalState_Withdrawn struct { - // The reason for the withdrawal. - Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` -} - -func (m *ProposalState_Withdrawn) Reset() { *m = ProposalState_Withdrawn{} } -func (m *ProposalState_Withdrawn) String() string { return proto.CompactTextString(m) } -func (*ProposalState_Withdrawn) ProtoMessage() {} -func (*ProposalState_Withdrawn) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{12, 1} -} -func (m *ProposalState_Withdrawn) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalState_Withdrawn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalState_Withdrawn.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 *ProposalState_Withdrawn) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalState_Withdrawn.Merge(m, src) -} -func (m *ProposalState_Withdrawn) XXX_Size() int { - return m.Size() -} -func (m *ProposalState_Withdrawn) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalState_Withdrawn.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalState_Withdrawn proto.InternalMessageInfo - -func (m *ProposalState_Withdrawn) GetReason() string { - if m != nil { - return m.Reason - } - return "" -} - -// The voting period has ended, and the proposal has been assigned an outcome. -type ProposalState_Finished struct { - Outcome *ProposalOutcome `protobuf:"bytes,1,opt,name=outcome,proto3" json:"outcome,omitempty"` -} - -func (m *ProposalState_Finished) Reset() { *m = ProposalState_Finished{} } -func (m *ProposalState_Finished) String() string { return proto.CompactTextString(m) } -func (*ProposalState_Finished) ProtoMessage() {} -func (*ProposalState_Finished) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{12, 2} -} -func (m *ProposalState_Finished) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalState_Finished) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalState_Finished.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 *ProposalState_Finished) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalState_Finished.Merge(m, src) -} -func (m *ProposalState_Finished) XXX_Size() int { - return m.Size() -} -func (m *ProposalState_Finished) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalState_Finished.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalState_Finished proto.InternalMessageInfo - -func (m *ProposalState_Finished) GetOutcome() *ProposalOutcome { - if m != nil { - return m.Outcome - } - return nil -} - -// The voting period has ended, and the original proposer has claimed their deposit. -type ProposalState_Claimed struct { - Outcome *ProposalOutcome `protobuf:"bytes,1,opt,name=outcome,proto3" json:"outcome,omitempty"` -} - -func (m *ProposalState_Claimed) Reset() { *m = ProposalState_Claimed{} } -func (m *ProposalState_Claimed) String() string { return proto.CompactTextString(m) } -func (*ProposalState_Claimed) ProtoMessage() {} -func (*ProposalState_Claimed) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{12, 3} -} -func (m *ProposalState_Claimed) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalState_Claimed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalState_Claimed.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 *ProposalState_Claimed) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalState_Claimed.Merge(m, src) -} -func (m *ProposalState_Claimed) XXX_Size() int { - return m.Size() -} -func (m *ProposalState_Claimed) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalState_Claimed.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalState_Claimed proto.InternalMessageInfo - -func (m *ProposalState_Claimed) GetOutcome() *ProposalOutcome { - if m != nil { - return m.Outcome - } - return nil -} - -// The outcome of a concluded proposal. -type ProposalOutcome struct { - // Types that are valid to be assigned to Outcome: - // - // *ProposalOutcome_Passed_ - // *ProposalOutcome_Failed_ - // *ProposalOutcome_Slashed_ - Outcome isProposalOutcome_Outcome `protobuf_oneof:"outcome"` -} - -func (m *ProposalOutcome) Reset() { *m = ProposalOutcome{} } -func (m *ProposalOutcome) String() string { return proto.CompactTextString(m) } -func (*ProposalOutcome) ProtoMessage() {} -func (*ProposalOutcome) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{13} -} -func (m *ProposalOutcome) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalOutcome) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalOutcome.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 *ProposalOutcome) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalOutcome.Merge(m, src) -} -func (m *ProposalOutcome) XXX_Size() int { - return m.Size() -} -func (m *ProposalOutcome) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalOutcome.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalOutcome proto.InternalMessageInfo - -type isProposalOutcome_Outcome interface { - isProposalOutcome_Outcome() - MarshalTo([]byte) (int, error) - Size() int -} - -type ProposalOutcome_Passed_ struct { - Passed *ProposalOutcome_Passed `protobuf:"bytes,1,opt,name=passed,proto3,oneof" json:"passed,omitempty"` -} -type ProposalOutcome_Failed_ struct { - Failed *ProposalOutcome_Failed `protobuf:"bytes,2,opt,name=failed,proto3,oneof" json:"failed,omitempty"` -} -type ProposalOutcome_Slashed_ struct { - Slashed *ProposalOutcome_Slashed `protobuf:"bytes,3,opt,name=slashed,proto3,oneof" json:"slashed,omitempty"` -} - -func (*ProposalOutcome_Passed_) isProposalOutcome_Outcome() {} -func (*ProposalOutcome_Failed_) isProposalOutcome_Outcome() {} -func (*ProposalOutcome_Slashed_) isProposalOutcome_Outcome() {} - -func (m *ProposalOutcome) GetOutcome() isProposalOutcome_Outcome { - if m != nil { - return m.Outcome - } - return nil -} - -func (m *ProposalOutcome) GetPassed() *ProposalOutcome_Passed { - if x, ok := m.GetOutcome().(*ProposalOutcome_Passed_); ok { - return x.Passed - } - return nil -} - -func (m *ProposalOutcome) GetFailed() *ProposalOutcome_Failed { - if x, ok := m.GetOutcome().(*ProposalOutcome_Failed_); ok { - return x.Failed - } - return nil -} - -func (m *ProposalOutcome) GetSlashed() *ProposalOutcome_Slashed { - if x, ok := m.GetOutcome().(*ProposalOutcome_Slashed_); ok { - return x.Slashed - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*ProposalOutcome) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*ProposalOutcome_Passed_)(nil), - (*ProposalOutcome_Failed_)(nil), - (*ProposalOutcome_Slashed_)(nil), - } -} - -// The proposal was passed. -type ProposalOutcome_Passed struct { -} - -func (m *ProposalOutcome_Passed) Reset() { *m = ProposalOutcome_Passed{} } -func (m *ProposalOutcome_Passed) String() string { return proto.CompactTextString(m) } -func (*ProposalOutcome_Passed) ProtoMessage() {} -func (*ProposalOutcome_Passed) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{13, 0} -} -func (m *ProposalOutcome_Passed) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalOutcome_Passed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalOutcome_Passed.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 *ProposalOutcome_Passed) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalOutcome_Passed.Merge(m, src) -} -func (m *ProposalOutcome_Passed) XXX_Size() int { - return m.Size() -} -func (m *ProposalOutcome_Passed) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalOutcome_Passed.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalOutcome_Passed proto.InternalMessageInfo - -// The proposal did not pass. -type ProposalOutcome_Failed struct { - // Types that are valid to be assigned to XWithdrawnWithReason: - // - // *ProposalOutcome_Failed_WithdrawnWithReason - XWithdrawnWithReason isProposalOutcome_Failed_XWithdrawnWithReason `protobuf_oneof:"_withdrawn_with_reason"` -} - -func (m *ProposalOutcome_Failed) Reset() { *m = ProposalOutcome_Failed{} } -func (m *ProposalOutcome_Failed) String() string { return proto.CompactTextString(m) } -func (*ProposalOutcome_Failed) ProtoMessage() {} -func (*ProposalOutcome_Failed) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{13, 1} -} -func (m *ProposalOutcome_Failed) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalOutcome_Failed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalOutcome_Failed.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 *ProposalOutcome_Failed) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalOutcome_Failed.Merge(m, src) -} -func (m *ProposalOutcome_Failed) XXX_Size() int { - return m.Size() -} -func (m *ProposalOutcome_Failed) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalOutcome_Failed.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalOutcome_Failed proto.InternalMessageInfo - -type isProposalOutcome_Failed_XWithdrawnWithReason interface { - isProposalOutcome_Failed_XWithdrawnWithReason() - MarshalTo([]byte) (int, error) - Size() int -} - -type ProposalOutcome_Failed_WithdrawnWithReason struct { - WithdrawnWithReason string `protobuf:"bytes,1,opt,name=withdrawn_with_reason,json=withdrawnWithReason,proto3,oneof" json:"withdrawn_with_reason,omitempty"` -} - -func (*ProposalOutcome_Failed_WithdrawnWithReason) isProposalOutcome_Failed_XWithdrawnWithReason() {} - -func (m *ProposalOutcome_Failed) GetXWithdrawnWithReason() isProposalOutcome_Failed_XWithdrawnWithReason { - if m != nil { - return m.XWithdrawnWithReason - } - return nil -} - -func (m *ProposalOutcome_Failed) GetWithdrawnWithReason() string { - if x, ok := m.GetXWithdrawnWithReason().(*ProposalOutcome_Failed_WithdrawnWithReason); ok { - return x.WithdrawnWithReason - } - return "" -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*ProposalOutcome_Failed) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*ProposalOutcome_Failed_WithdrawnWithReason)(nil), - } -} - -// The proposal did not pass, and was slashed. -type ProposalOutcome_Slashed struct { - // Types that are valid to be assigned to XWithdrawnWithReason: - // - // *ProposalOutcome_Slashed_WithdrawnWithReason - XWithdrawnWithReason isProposalOutcome_Slashed_XWithdrawnWithReason `protobuf_oneof:"_withdrawn_with_reason"` -} - -func (m *ProposalOutcome_Slashed) Reset() { *m = ProposalOutcome_Slashed{} } -func (m *ProposalOutcome_Slashed) String() string { return proto.CompactTextString(m) } -func (*ProposalOutcome_Slashed) ProtoMessage() {} -func (*ProposalOutcome_Slashed) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{13, 2} -} -func (m *ProposalOutcome_Slashed) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ProposalOutcome_Slashed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ProposalOutcome_Slashed.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 *ProposalOutcome_Slashed) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProposalOutcome_Slashed.Merge(m, src) -} -func (m *ProposalOutcome_Slashed) XXX_Size() int { - return m.Size() -} -func (m *ProposalOutcome_Slashed) XXX_DiscardUnknown() { - xxx_messageInfo_ProposalOutcome_Slashed.DiscardUnknown(m) -} - -var xxx_messageInfo_ProposalOutcome_Slashed proto.InternalMessageInfo - -type isProposalOutcome_Slashed_XWithdrawnWithReason interface { - isProposalOutcome_Slashed_XWithdrawnWithReason() - MarshalTo([]byte) (int, error) - Size() int -} - -type ProposalOutcome_Slashed_WithdrawnWithReason struct { - WithdrawnWithReason string `protobuf:"bytes,1,opt,name=withdrawn_with_reason,json=withdrawnWithReason,proto3,oneof" json:"withdrawn_with_reason,omitempty"` -} - -func (*ProposalOutcome_Slashed_WithdrawnWithReason) isProposalOutcome_Slashed_XWithdrawnWithReason() { -} - -func (m *ProposalOutcome_Slashed) GetXWithdrawnWithReason() isProposalOutcome_Slashed_XWithdrawnWithReason { - if m != nil { - return m.XWithdrawnWithReason - } - return nil -} - -func (m *ProposalOutcome_Slashed) GetWithdrawnWithReason() string { - if x, ok := m.GetXWithdrawnWithReason().(*ProposalOutcome_Slashed_WithdrawnWithReason); ok { - return x.WithdrawnWithReason - } - return "" -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*ProposalOutcome_Slashed) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*ProposalOutcome_Slashed_WithdrawnWithReason)(nil), - } -} - -// A tally of votes on a proposal. -type Tally struct { - // The number of votes in favor of the proposal. - Yes uint64 `protobuf:"varint,1,opt,name=yes,proto3" json:"yes,omitempty"` - // The number of votes against the proposal. - No uint64 `protobuf:"varint,2,opt,name=no,proto3" json:"no,omitempty"` - // The number of abstentions. - Abstain uint64 `protobuf:"varint,3,opt,name=abstain,proto3" json:"abstain,omitempty"` -} - -func (m *Tally) Reset() { *m = Tally{} } -func (m *Tally) String() string { return proto.CompactTextString(m) } -func (*Tally) ProtoMessage() {} -func (*Tally) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{14} -} -func (m *Tally) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Tally) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Tally.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 *Tally) XXX_Merge(src proto.Message) { - xxx_messageInfo_Tally.Merge(m, src) -} -func (m *Tally) XXX_Size() int { - return m.Size() -} -func (m *Tally) XXX_DiscardUnknown() { - xxx_messageInfo_Tally.DiscardUnknown(m) -} - -var xxx_messageInfo_Tally proto.InternalMessageInfo - -func (m *Tally) GetYes() uint64 { - if m != nil { - return m.Yes - } - return 0 -} - -func (m *Tally) GetNo() uint64 { - if m != nil { - return m.No - } - return 0 -} - -func (m *Tally) GetAbstain() uint64 { - if m != nil { - return m.Abstain - } - return 0 -} - -// A proposal to be voted upon. -type Proposal struct { - // The unique identifier of the proposal. - Id uint64 `protobuf:"varint,4,opt,name=id,proto3" json:"id,omitempty"` - // A short title for the proposal. - Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` - // A natural-language description of the effect of the proposal and its justification. - Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` - // The different kinds of proposal. Only one of these should be set. - Signaling *Proposal_Signaling `protobuf:"bytes,5,opt,name=signaling,proto3" json:"signaling,omitempty"` - Emergency *Proposal_Emergency `protobuf:"bytes,6,opt,name=emergency,proto3" json:"emergency,omitempty"` - ParameterChange *Proposal_ParameterChange `protobuf:"bytes,7,opt,name=parameter_change,json=parameterChange,proto3" json:"parameter_change,omitempty"` - DaoSpend *Proposal_DaoSpend `protobuf:"bytes,8,opt,name=dao_spend,json=daoSpend,proto3" json:"dao_spend,omitempty"` -} - -func (m *Proposal) Reset() { *m = Proposal{} } -func (m *Proposal) String() string { return proto.CompactTextString(m) } -func (*Proposal) ProtoMessage() {} -func (*Proposal) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{15} -} -func (m *Proposal) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Proposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Proposal.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 *Proposal) XXX_Merge(src proto.Message) { - xxx_messageInfo_Proposal.Merge(m, src) -} -func (m *Proposal) XXX_Size() int { - return m.Size() -} -func (m *Proposal) XXX_DiscardUnknown() { - xxx_messageInfo_Proposal.DiscardUnknown(m) -} - -var xxx_messageInfo_Proposal proto.InternalMessageInfo - -func (m *Proposal) GetId() uint64 { - if m != nil { - return m.Id - } - return 0 -} - -func (m *Proposal) GetTitle() string { - if m != nil { - return m.Title - } - return "" -} - -func (m *Proposal) GetDescription() string { - if m != nil { - return m.Description - } - return "" -} - -func (m *Proposal) GetSignaling() *Proposal_Signaling { - if m != nil { - return m.Signaling - } - return nil -} - -func (m *Proposal) GetEmergency() *Proposal_Emergency { - if m != nil { - return m.Emergency - } - return nil -} - -func (m *Proposal) GetParameterChange() *Proposal_ParameterChange { - if m != nil { - return m.ParameterChange - } - return nil -} - -func (m *Proposal) GetDaoSpend() *Proposal_DaoSpend { - if m != nil { - return m.DaoSpend - } - return nil -} - -// A signaling proposal is meant to register a vote on-chain, but does not have an automatic -// effect when passed. -// -// It optionally contains a reference to a commit which contains code to upgrade the chain. -type Proposal_Signaling struct { - // Types that are valid to be assigned to XCommit: - // - // *Proposal_Signaling_Commit - XCommit isProposal_Signaling_XCommit `protobuf_oneof:"_commit"` -} - -func (m *Proposal_Signaling) Reset() { *m = Proposal_Signaling{} } -func (m *Proposal_Signaling) String() string { return proto.CompactTextString(m) } -func (*Proposal_Signaling) ProtoMessage() {} -func (*Proposal_Signaling) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{15, 0} -} -func (m *Proposal_Signaling) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Proposal_Signaling) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Proposal_Signaling.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 *Proposal_Signaling) XXX_Merge(src proto.Message) { - xxx_messageInfo_Proposal_Signaling.Merge(m, src) -} -func (m *Proposal_Signaling) XXX_Size() int { - return m.Size() -} -func (m *Proposal_Signaling) XXX_DiscardUnknown() { - xxx_messageInfo_Proposal_Signaling.DiscardUnknown(m) -} - -var xxx_messageInfo_Proposal_Signaling proto.InternalMessageInfo - -type isProposal_Signaling_XCommit interface { - isProposal_Signaling_XCommit() - MarshalTo([]byte) (int, error) - Size() int -} - -type Proposal_Signaling_Commit struct { - Commit string `protobuf:"bytes,1,opt,name=commit,proto3,oneof" json:"commit,omitempty"` -} - -func (*Proposal_Signaling_Commit) isProposal_Signaling_XCommit() {} - -func (m *Proposal_Signaling) GetXCommit() isProposal_Signaling_XCommit { - if m != nil { - return m.XCommit - } - return nil -} - -func (m *Proposal_Signaling) GetCommit() string { - if x, ok := m.GetXCommit().(*Proposal_Signaling_Commit); ok { - return x.Commit - } - return "" -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*Proposal_Signaling) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*Proposal_Signaling_Commit)(nil), - } -} - -// An emergency proposal can be passed instantaneously by a 2/3 majority of validators, without -// waiting for the voting period to expire. -// -// If the boolean `halt_chain` is set to `true`, then the chain will halt immediately when the -// proposal is passed. -type Proposal_Emergency struct { - // If `true`, the chain will halt immediately when the proposal is passed. - HaltChain bool `protobuf:"varint,1,opt,name=halt_chain,json=haltChain,proto3" json:"halt_chain,omitempty"` -} - -func (m *Proposal_Emergency) Reset() { *m = Proposal_Emergency{} } -func (m *Proposal_Emergency) String() string { return proto.CompactTextString(m) } -func (*Proposal_Emergency) ProtoMessage() {} -func (*Proposal_Emergency) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{15, 1} -} -func (m *Proposal_Emergency) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Proposal_Emergency) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Proposal_Emergency.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 *Proposal_Emergency) XXX_Merge(src proto.Message) { - xxx_messageInfo_Proposal_Emergency.Merge(m, src) -} -func (m *Proposal_Emergency) XXX_Size() int { - return m.Size() -} -func (m *Proposal_Emergency) XXX_DiscardUnknown() { - xxx_messageInfo_Proposal_Emergency.DiscardUnknown(m) -} - -var xxx_messageInfo_Proposal_Emergency proto.InternalMessageInfo - -func (m *Proposal_Emergency) GetHaltChain() bool { - if m != nil { - return m.HaltChain - } - return false -} - -// A parameter change proposal describes a replacement of the chain parameters, which should take -// effect when the proposal is passed. -type Proposal_ParameterChange struct { - // The old chain parameters to be replaced: even if the proposal passes, the update will not be - // applied if the chain parameters have changed *at all* from these chain parameters. Usually, - // this should be set to the current chain parameters at time of proposal. - OldParameters *v1alpha11.ChainParameters `protobuf:"bytes,1,opt,name=old_parameters,json=oldParameters,proto3" json:"old_parameters,omitempty"` - // The new chain parameters to be set: the *entire* chain parameters will be replaced with these - // at the time the proposal is passed. - NewParameters *v1alpha11.ChainParameters `protobuf:"bytes,2,opt,name=new_parameters,json=newParameters,proto3" json:"new_parameters,omitempty"` -} - -func (m *Proposal_ParameterChange) Reset() { *m = Proposal_ParameterChange{} } -func (m *Proposal_ParameterChange) String() string { return proto.CompactTextString(m) } -func (*Proposal_ParameterChange) ProtoMessage() {} -func (*Proposal_ParameterChange) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{15, 2} -} -func (m *Proposal_ParameterChange) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Proposal_ParameterChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Proposal_ParameterChange.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 *Proposal_ParameterChange) XXX_Merge(src proto.Message) { - xxx_messageInfo_Proposal_ParameterChange.Merge(m, src) -} -func (m *Proposal_ParameterChange) XXX_Size() int { - return m.Size() -} -func (m *Proposal_ParameterChange) XXX_DiscardUnknown() { - xxx_messageInfo_Proposal_ParameterChange.DiscardUnknown(m) -} - -var xxx_messageInfo_Proposal_ParameterChange proto.InternalMessageInfo - -func (m *Proposal_ParameterChange) GetOldParameters() *v1alpha11.ChainParameters { - if m != nil { - return m.OldParameters - } - return nil -} - -func (m *Proposal_ParameterChange) GetNewParameters() *v1alpha11.ChainParameters { - if m != nil { - return m.NewParameters - } - return nil -} - -// A DAO spend proposal describes zero or more transactions to execute on behalf of the DAO, with -// access to its funds, and zero or more scheduled transactions from previous passed proposals to -// cancel. -type Proposal_DaoSpend struct { - // The transaction plan to be executed at the time the proposal is passed. This must be a - // transaction plan which can be executed by the DAO, which means it can't require any witness - // data or authorization signatures, but it may use the `DaoSpend` action. - TransactionPlan *types.Any `protobuf:"bytes,2,opt,name=transaction_plan,json=transactionPlan,proto3" json:"transaction_plan,omitempty"` -} - -func (m *Proposal_DaoSpend) Reset() { *m = Proposal_DaoSpend{} } -func (m *Proposal_DaoSpend) String() string { return proto.CompactTextString(m) } -func (*Proposal_DaoSpend) ProtoMessage() {} -func (*Proposal_DaoSpend) Descriptor() ([]byte, []int) { - return fileDescriptor_1bc89f5bf0aed114, []int{15, 3} -} -func (m *Proposal_DaoSpend) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Proposal_DaoSpend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Proposal_DaoSpend.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 *Proposal_DaoSpend) XXX_Merge(src proto.Message) { - xxx_messageInfo_Proposal_DaoSpend.Merge(m, src) -} -func (m *Proposal_DaoSpend) XXX_Size() int { - return m.Size() -} -func (m *Proposal_DaoSpend) XXX_DiscardUnknown() { - xxx_messageInfo_Proposal_DaoSpend.DiscardUnknown(m) -} - -var xxx_messageInfo_Proposal_DaoSpend proto.InternalMessageInfo - -func (m *Proposal_DaoSpend) GetTransactionPlan() *types.Any { - if m != nil { - return m.TransactionPlan - } - return nil -} - -func init() { - proto.RegisterEnum("penumbra.core.governance.v1alpha1.Vote_Vote", Vote_Vote_name, Vote_Vote_value) - proto.RegisterType((*ProposalSubmit)(nil), "penumbra.core.governance.v1alpha1.ProposalSubmit") - proto.RegisterType((*ProposalWithdraw)(nil), "penumbra.core.governance.v1alpha1.ProposalWithdraw") - proto.RegisterType((*ProposalDepositClaim)(nil), "penumbra.core.governance.v1alpha1.ProposalDepositClaim") - proto.RegisterType((*ValidatorVote)(nil), "penumbra.core.governance.v1alpha1.ValidatorVote") - proto.RegisterType((*ValidatorVoteBody)(nil), "penumbra.core.governance.v1alpha1.ValidatorVoteBody") - proto.RegisterType((*DelegatorVote)(nil), "penumbra.core.governance.v1alpha1.DelegatorVote") - proto.RegisterType((*DelegatorVoteBody)(nil), "penumbra.core.governance.v1alpha1.DelegatorVoteBody") - proto.RegisterType((*DelegatorVotePlan)(nil), "penumbra.core.governance.v1alpha1.DelegatorVotePlan") - proto.RegisterType((*DaoDeposit)(nil), "penumbra.core.governance.v1alpha1.DaoDeposit") - proto.RegisterType((*DaoSpend)(nil), "penumbra.core.governance.v1alpha1.DaoSpend") - proto.RegisterType((*DaoOutput)(nil), "penumbra.core.governance.v1alpha1.DaoOutput") - proto.RegisterType((*Vote)(nil), "penumbra.core.governance.v1alpha1.Vote") - proto.RegisterType((*ProposalState)(nil), "penumbra.core.governance.v1alpha1.ProposalState") - proto.RegisterType((*ProposalState_Voting)(nil), "penumbra.core.governance.v1alpha1.ProposalState.Voting") - proto.RegisterType((*ProposalState_Withdrawn)(nil), "penumbra.core.governance.v1alpha1.ProposalState.Withdrawn") - proto.RegisterType((*ProposalState_Finished)(nil), "penumbra.core.governance.v1alpha1.ProposalState.Finished") - proto.RegisterType((*ProposalState_Claimed)(nil), "penumbra.core.governance.v1alpha1.ProposalState.Claimed") - proto.RegisterType((*ProposalOutcome)(nil), "penumbra.core.governance.v1alpha1.ProposalOutcome") - proto.RegisterType((*ProposalOutcome_Passed)(nil), "penumbra.core.governance.v1alpha1.ProposalOutcome.Passed") - proto.RegisterType((*ProposalOutcome_Failed)(nil), "penumbra.core.governance.v1alpha1.ProposalOutcome.Failed") - proto.RegisterType((*ProposalOutcome_Slashed)(nil), "penumbra.core.governance.v1alpha1.ProposalOutcome.Slashed") - proto.RegisterType((*Tally)(nil), "penumbra.core.governance.v1alpha1.Tally") - proto.RegisterType((*Proposal)(nil), "penumbra.core.governance.v1alpha1.Proposal") - proto.RegisterType((*Proposal_Signaling)(nil), "penumbra.core.governance.v1alpha1.Proposal.Signaling") - proto.RegisterType((*Proposal_Emergency)(nil), "penumbra.core.governance.v1alpha1.Proposal.Emergency") - proto.RegisterType((*Proposal_ParameterChange)(nil), "penumbra.core.governance.v1alpha1.Proposal.ParameterChange") - proto.RegisterType((*Proposal_DaoSpend)(nil), "penumbra.core.governance.v1alpha1.Proposal.DaoSpend") -} - -func init() { - proto.RegisterFile("penumbra/core/governance/v1alpha1/governance.proto", fileDescriptor_1bc89f5bf0aed114) -} - -var fileDescriptor_1bc89f5bf0aed114 = []byte{ - // 1546 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x5d, 0x6f, 0x1b, 0x45, - 0x17, 0xf6, 0x3a, 0x8e, 0x3f, 0x4e, 0x12, 0xc7, 0x9d, 0x37, 0x6f, 0xe5, 0xd7, 0x2f, 0x44, 0xa9, - 0xdb, 0x42, 0x54, 0xa8, 0x4d, 0x53, 0x50, 0xa9, 0x7b, 0x41, 0x63, 0xe7, 0x53, 0x6d, 0x13, 0x77, - 0x1d, 0x52, 0x28, 0x91, 0x96, 0xb1, 0x77, 0x62, 0xaf, 0xb2, 0x9e, 0xb1, 0x76, 0xc7, 0x89, 0xcc, - 0x2f, 0x80, 0xbb, 0x4a, 0xfc, 0x03, 0x24, 0x84, 0xc4, 0x7f, 0xe0, 0x1e, 0x21, 0x01, 0xbd, 0x2c, - 0x77, 0x28, 0xb9, 0xe3, 0x92, 0x5f, 0x80, 0x66, 0x76, 0xf6, 0x23, 0x1f, 0xd4, 0x75, 0x42, 0xc5, - 0xdd, 0x9c, 0xe3, 0xf3, 0x3c, 0xe7, 0x63, 0xce, 0xcc, 0x1c, 0x2f, 0x2c, 0xf4, 0x08, 0xed, 0x77, - 0x9b, 0x0e, 0x2e, 0xb7, 0x98, 0x43, 0xca, 0x6d, 0xb6, 0x4f, 0x1c, 0x8a, 0x69, 0x8b, 0x94, 0xf7, - 0x6f, 0x61, 0xbb, 0xd7, 0xc1, 0xb7, 0x22, 0xba, 0x52, 0xcf, 0x61, 0x9c, 0xa1, 0x2b, 0x3e, 0xa6, - 0x24, 0x30, 0xa5, 0xc8, 0xef, 0x3e, 0xa6, 0xf0, 0xbf, 0x36, 0x63, 0x6d, 0x9b, 0x94, 0x25, 0xa0, - 0xd9, 0xdf, 0x2d, 0x63, 0x3a, 0xf0, 0xd0, 0x85, 0x1b, 0xc7, 0x3d, 0xb6, 0x9c, 0x41, 0x8f, 0xb3, - 0xd0, 0x9b, 0x27, 0x2b, 0xdb, 0xf9, 0x13, 0xb6, 0x1d, 0x6c, 0xd1, 0x88, 0xa9, 0x10, 0x3d, 0xcb, - 0xe2, 0x77, 0x1a, 0x64, 0xeb, 0x0e, 0xeb, 0x31, 0x17, 0xdb, 0x8d, 0x7e, 0xb3, 0x6b, 0x71, 0xb4, - 0x0a, 0xe9, 0x9e, 0xd2, 0xe4, 0xb5, 0x39, 0x6d, 0x7e, 0x62, 0xe1, 0x9d, 0xd2, 0xd0, 0xc8, 0x4b, - 0x3e, 0x89, 0x1e, 0x80, 0xd1, 0x43, 0xc8, 0x9a, 0xa4, 0xc7, 0x5c, 0x8b, 0x1b, 0xb8, 0xcb, 0xfa, - 0x94, 0xe7, 0xc7, 0x24, 0xdd, 0xf5, 0x13, 0x74, 0x2a, 0xf4, 0x80, 0x6a, 0x51, 0x1a, 0xeb, 0x53, - 0x0a, 0xec, 0x89, 0xc5, 0x15, 0xc8, 0xf9, 0x3e, 0x9e, 0x58, 0xbc, 0x63, 0x3a, 0xf8, 0x00, 0x15, - 0x4e, 0x84, 0x9a, 0x88, 0x78, 0xbf, 0x0c, 0x49, 0x87, 0x60, 0x97, 0xd1, 0x7c, 0x7c, 0x4e, 0x9b, - 0xcf, 0xe8, 0x4a, 0x2a, 0xfe, 0xa2, 0xc1, 0x8c, 0x4f, 0xb4, 0xe4, 0x79, 0xa8, 0xd9, 0xd8, 0xea, - 0xbe, 0x94, 0xec, 0x74, 0x2a, 0xf1, 0xf3, 0xa7, 0x82, 0x1e, 0x42, 0x8a, 0xf5, 0x79, 0x8b, 0x75, - 0x89, 0xaa, 0xc8, 0xc2, 0x08, 0x05, 0xde, 0xf4, 0x90, 0xba, 0x4f, 0x21, 0xb6, 0x70, 0x6a, 0x1b, - 0xdb, 0x96, 0x89, 0x39, 0x73, 0xb6, 0x19, 0x27, 0x68, 0x0d, 0x12, 0x4d, 0x66, 0x0e, 0xd4, 0xee, - 0xbd, 0xff, 0x0a, 0xe4, 0xc7, 0xf0, 0x55, 0x66, 0x0e, 0x74, 0xc9, 0x80, 0x1e, 0x42, 0x1a, 0xf7, - 0x79, 0xc7, 0x70, 0xad, 0xb6, 0xca, 0xf8, 0xd6, 0x90, 0x8c, 0x1b, 0x3d, 0x42, 0xcd, 0xc5, 0x3e, - 0xef, 0x34, 0xac, 0x36, 0xc5, 0xbc, 0xef, 0x10, 0x3d, 0x85, 0x3d, 0xb1, 0xf8, 0x2c, 0x0e, 0x97, - 0x4e, 0x79, 0x7a, 0x69, 0xdd, 0xef, 0x41, 0x62, 0x9f, 0x71, 0xa2, 0x7c, 0xbf, 0xfd, 0x2a, 0x99, - 0x30, 0x4e, 0x74, 0x09, 0x42, 0x8f, 0x60, 0xd2, 0x32, 0x09, 0xe5, 0x16, 0x1f, 0x18, 0x7b, 0x64, - 0xa0, 0x6a, 0x7d, 0x63, 0x48, 0x02, 0xeb, 0x0a, 0xf2, 0x80, 0x0c, 0xf4, 0x09, 0x2b, 0x14, 0x50, - 0x03, 0xb2, 0xa1, 0x43, 0x49, 0x98, 0x90, 0x84, 0xef, 0x0e, 0x21, 0x5c, 0x0d, 0x40, 0x82, 0x72, - 0xaa, 0x1d, 0x15, 0x8b, 0x7f, 0x6a, 0x30, 0xb5, 0x44, 0x6c, 0xd2, 0xbe, 0xc0, 0xe6, 0x1d, 0xc3, - 0xbf, 0xae, 0xcd, 0x43, 0xeb, 0x30, 0xde, 0x73, 0x18, 0xdb, 0x55, 0x65, 0xbc, 0x3d, 0x84, 0xea, - 0xe9, 0x83, 0x63, 0x61, 0xd5, 0x05, 0x54, 0xf7, 0x18, 0x8a, 0x3f, 0xc7, 0xe1, 0xd2, 0xa9, 0xa0, - 0x5f, 0xda, 0x07, 0xd7, 0x21, 0xeb, 0x72, 0xec, 0x70, 0x43, 0x1e, 0x23, 0x4b, 0x1d, 0xea, 0x84, - 0x3e, 0x25, 0xb5, 0x75, 0xa5, 0x0c, 0xda, 0x65, 0xec, 0x3c, 0xed, 0x52, 0x81, 0xf1, 0x7d, 0x6c, - 0xf7, 0x89, 0xda, 0xd6, 0x6b, 0x43, 0x12, 0xdc, 0x16, 0xb6, 0xba, 0x07, 0x41, 0x1b, 0x30, 0xdd, - 0xa7, 0x4d, 0x46, 0x4d, 0x62, 0xfa, 0x17, 0xc4, 0xf8, 0x28, 0x17, 0x44, 0xd6, 0x47, 0xab, 0x1b, - 0xe2, 0x0d, 0xc8, 0xd0, 0xbe, 0x6d, 0x5b, 0xbb, 0x16, 0x71, 0xf2, 0xc9, 0x39, 0x6d, 0x7e, 0x52, - 0x0f, 0x15, 0x28, 0x0b, 0x71, 0x67, 0x2f, 0x9f, 0x92, 0xea, 0xb8, 0xb3, 0x57, 0xfc, 0x75, 0xec, - 0x44, 0x3d, 0xeb, 0x36, 0xa6, 0xff, 0x7a, 0x3d, 0x97, 0x60, 0xc2, 0xe5, 0x78, 0x8f, 0x98, 0x06, - 0x15, 0x1c, 0x5e, 0x55, 0xaf, 0x0e, 0xa9, 0xc7, 0x86, 0xc0, 0x83, 0x87, 0x13, 0x6b, 0xf4, 0x1e, - 0xcc, 0x44, 0x58, 0xc2, 0x78, 0xc7, 0x65, 0xbc, 0x28, 0xb4, 0x0c, 0x82, 0x3e, 0x63, 0x2f, 0x92, - 0x17, 0xd9, 0x8b, 0x59, 0x00, 0x07, 0x53, 0x93, 0x75, 0xad, 0x2f, 0x88, 0xa3, 0xaa, 0x1e, 0xd1, - 0xa0, 0x79, 0xc8, 0xc9, 0xb6, 0x36, 0x9a, 0xb6, 0x45, 0x4d, 0x8b, 0xb6, 0x0d, 0x27, 0x9f, 0x96, - 0x56, 0x59, 0xa9, 0xaf, 0x2a, 0xb5, 0x7e, 0x86, 0xa5, 0x9b, 0xcf, 0x9c, 0x61, 0xd9, 0x28, 0xae, - 0x01, 0x2c, 0x61, 0xa6, 0x9e, 0xa7, 0xb0, 0x33, 0xb5, 0x91, 0x3b, 0xb3, 0xb8, 0x02, 0xe9, 0x25, - 0xcc, 0xe4, 0xc1, 0xbe, 0x10, 0xcf, 0x57, 0x1a, 0x64, 0x96, 0x30, 0xdb, 0xec, 0xf3, 0x5e, 0xff, - 0x42, 0x11, 0xa1, 0xfb, 0x90, 0xc2, 0xa6, 0xe9, 0x10, 0xd7, 0x55, 0xb7, 0xd2, 0x5b, 0xc3, 0xf6, - 0xc5, 0xb3, 0xd6, 0x7d, 0x58, 0xf1, 0x6b, 0x0d, 0x12, 0xf2, 0xae, 0xbc, 0xaf, 0xfa, 0x53, 0x44, - 0x91, 0x3d, 0x75, 0x11, 0xff, 0x5d, 0x7f, 0x46, 0x9a, 0xb4, 0xb8, 0xae, 0x98, 0x66, 0x20, 0xb7, - 0xbd, 0xb9, 0xb5, 0x6c, 0x7c, 0xbc, 0xd1, 0xa8, 0x2f, 0xd7, 0xd6, 0x57, 0xd6, 0x97, 0x97, 0x72, - 0x31, 0x94, 0x83, 0x49, 0xa9, 0x5d, 0xac, 0x36, 0xb6, 0x16, 0xd7, 0x37, 0x72, 0x1a, 0x9a, 0x84, - 0xb4, 0xd4, 0x7c, 0xba, 0xdc, 0xc8, 0xc5, 0xd1, 0x04, 0xa4, 0xa4, 0xb4, 0xb1, 0x99, 0x1b, 0x2b, - 0xbe, 0x48, 0xc0, 0x54, 0x30, 0x4a, 0x71, 0xcc, 0x09, 0x7a, 0x0c, 0xc9, 0x7d, 0xc6, 0x2d, 0xea, - 0x5f, 0xbf, 0x77, 0x46, 0x78, 0xe6, 0x25, 0x83, 0x88, 0xd4, 0xa2, 0xed, 0xb5, 0x98, 0xae, 0x88, - 0xd0, 0x53, 0xc8, 0x1c, 0xa8, 0xe9, 0x87, 0xaa, 0x63, 0x59, 0x19, 0x99, 0xd5, 0x9f, 0x9f, 0xe8, - 0x5a, 0x4c, 0x0f, 0xe9, 0xd0, 0x13, 0x48, 0xef, 0x5a, 0xd4, 0x72, 0x3b, 0xc4, 0x54, 0xa7, 0xf5, - 0xee, 0xc8, 0xd4, 0x2b, 0x8a, 0x60, 0x2d, 0xa6, 0x07, 0x64, 0x68, 0x0b, 0x52, 0x2d, 0x31, 0x62, - 0x11, 0x53, 0xdd, 0x8a, 0x1f, 0x8e, 0xcc, 0x5b, 0xf3, 0xf0, 0x6b, 0x31, 0xdd, 0xa7, 0x2a, 0xa4, - 0x21, 0xe9, 0x95, 0xa7, 0x70, 0x15, 0x32, 0x41, 0x4a, 0x91, 0xb9, 0x4f, 0x8b, 0xce, 0x7d, 0x85, - 0x4f, 0x20, 0xed, 0x07, 0x17, 0x1d, 0xc0, 0xb4, 0x0b, 0x0f, 0x60, 0x85, 0x27, 0x90, 0x52, 0xe1, - 0xfd, 0xb3, 0xc4, 0xd5, 0x14, 0x8c, 0xbb, 0x22, 0xfb, 0xe2, 0xd1, 0x18, 0x4c, 0x9f, 0xb0, 0x42, - 0x0d, 0x48, 0xf6, 0xb0, 0xeb, 0x12, 0x53, 0x79, 0xba, 0x3b, 0xba, 0xa7, 0x52, 0x5d, 0x12, 0x88, - 0xf6, 0xf2, 0xa8, 0x04, 0xe9, 0x2e, 0xb6, 0x6c, 0x62, 0xaa, 0x8e, 0x3d, 0x0f, 0xe9, 0x8a, 0x24, - 0x10, 0xa4, 0x1e, 0x15, 0xda, 0x86, 0x94, 0x6b, 0x63, 0xd9, 0x56, 0xa3, 0x77, 0xac, 0xcf, 0xda, - 0xf0, 0x18, 0x44, 0x03, 0x28, 0x32, 0xd1, 0x00, 0x5e, 0x02, 0x85, 0xcf, 0x20, 0xe9, 0x79, 0x45, - 0x77, 0xe0, 0xbf, 0x41, 0x43, 0x1b, 0x62, 0x65, 0x44, 0x9b, 0x61, 0x2d, 0xa6, 0xff, 0x27, 0xf8, - 0x59, 0xb4, 0x8c, 0x2e, 0x7f, 0xfc, 0x52, 0xd3, 0xaa, 0x79, 0xb8, 0x6c, 0x9c, 0x89, 0x2c, 0xec, - 0x40, 0x4a, 0x39, 0x7f, 0x0d, 0xec, 0xd5, 0x4c, 0xd0, 0x31, 0xc5, 0x1a, 0x8c, 0x6f, 0x61, 0xdb, - 0x1e, 0xa0, 0x1c, 0x8c, 0x0d, 0x88, 0xab, 0x1e, 0x6d, 0xb1, 0x14, 0x2f, 0x3e, 0x65, 0xea, 0x8d, - 0x8e, 0x53, 0x86, 0xf2, 0x90, 0xc2, 0x4d, 0x97, 0x63, 0xcb, 0xbb, 0x04, 0x12, 0xba, 0x2f, 0x16, - 0xbf, 0x4d, 0x42, 0xda, 0xaf, 0x9d, 0x80, 0x59, 0xde, 0x59, 0x4e, 0xe8, 0x71, 0xcb, 0x44, 0x33, - 0x30, 0xce, 0x2d, 0x6e, 0x13, 0x75, 0x34, 0x3c, 0x01, 0xcd, 0xc1, 0x84, 0x49, 0xdc, 0x96, 0x63, - 0xf5, 0x82, 0x49, 0x20, 0xa3, 0x47, 0x55, 0xa8, 0x01, 0x19, 0x57, 0x4c, 0x84, 0xb6, 0xb8, 0xcb, - 0xbc, 0x23, 0xfc, 0xc1, 0x08, 0x7b, 0x58, 0x6a, 0xf8, 0x60, 0x3d, 0xe4, 0x11, 0xa4, 0xa4, 0x4b, - 0x9c, 0x36, 0xa1, 0xad, 0x81, 0x7a, 0xa1, 0x47, 0x22, 0x5d, 0xf6, 0xc1, 0x7a, 0xc8, 0x83, 0x76, - 0x21, 0xd7, 0xc3, 0x0e, 0xee, 0x12, 0x4e, 0x1c, 0xa3, 0xd5, 0xc1, 0xb4, 0x4d, 0xe4, 0x93, 0x3d, - 0xb1, 0x70, 0x6f, 0x14, 0xee, 0xba, 0xcf, 0x51, 0x93, 0x14, 0xfa, 0x74, 0xef, 0xb8, 0x02, 0x3d, - 0x86, 0x8c, 0x89, 0x99, 0xe1, 0x8a, 0x77, 0x55, 0xbe, 0xf6, 0xaf, 0x36, 0xaa, 0x07, 0x0e, 0xfc, - 0x37, 0x59, 0x4f, 0x9b, 0x6a, 0x55, 0xb8, 0x0d, 0x99, 0xa0, 0x4e, 0xe8, 0xff, 0x90, 0x6c, 0xb1, - 0x6e, 0xd7, 0xe2, 0x41, 0x6b, 0x29, 0x59, 0x74, 0x53, 0x06, 0x52, 0x86, 0x27, 0x15, 0x6e, 0x40, - 0x26, 0xa8, 0x03, 0x7a, 0x13, 0xa0, 0x83, 0x6d, 0x6e, 0xc8, 0x3f, 0xf8, 0x12, 0x98, 0xd6, 0x33, - 0x42, 0x53, 0x13, 0x8a, 0xc2, 0x0f, 0x1a, 0x4c, 0x9f, 0x48, 0x0c, 0x6d, 0x41, 0x96, 0xd9, 0xa6, - 0x11, 0xa4, 0xe7, 0xaa, 0xdb, 0xe4, 0xe6, 0xc9, 0x37, 0x59, 0x7e, 0x33, 0x08, 0xf2, 0x90, 0x84, - 0x01, 0x97, 0xab, 0x4f, 0x31, 0xdb, 0x0c, 0x45, 0xc1, 0x4a, 0xc9, 0x41, 0x94, 0x35, 0x7e, 0x2e, - 0x56, 0x4a, 0x0e, 0x42, 0xb1, 0xf0, 0x20, 0x32, 0xca, 0x7c, 0x04, 0x39, 0xee, 0x60, 0xea, 0xe2, - 0x96, 0x68, 0x50, 0xa3, 0x67, 0x63, 0xaa, 0x7c, 0xcc, 0x94, 0xbc, 0x6f, 0x28, 0x25, 0xff, 0x1b, - 0x4a, 0x69, 0x91, 0x0e, 0xf4, 0xe9, 0x88, 0xb5, 0x98, 0x8e, 0xab, 0xbf, 0xc5, 0x7f, 0x3c, 0x9c, - 0xd5, 0x9e, 0x1f, 0xce, 0x6a, 0xbf, 0x1f, 0xce, 0x6a, 0xcf, 0x8e, 0x66, 0x63, 0xcf, 0x8f, 0x66, - 0x63, 0x2f, 0x8e, 0x66, 0x63, 0x70, 0xbd, 0xc5, 0xba, 0xc3, 0xf7, 0xb2, 0x3a, 0x1d, 0xfe, 0xb1, - 0xab, 0x0b, 0x57, 0x75, 0xed, 0xe9, 0xe7, 0x6d, 0x8b, 0x77, 0xfa, 0xcd, 0x52, 0x8b, 0x75, 0xcb, - 0x2d, 0xe6, 0x76, 0x99, 0x5b, 0x76, 0x88, 0x8d, 0x07, 0xc4, 0x29, 0xef, 0x2f, 0x04, 0x4b, 0x99, - 0xb5, 0x5b, 0x1e, 0xfa, 0x05, 0xe9, 0x5e, 0xa8, 0xf3, 0x55, 0xdf, 0xc4, 0xc7, 0xea, 0xb5, 0xd5, - 0xef, 0xe3, 0x57, 0xea, 0x7e, 0x78, 0x35, 0x11, 0x5e, 0x18, 0x49, 0x69, 0x5b, 0x59, 0xfe, 0x14, - 0xda, 0xec, 0x08, 0x9b, 0x9d, 0xd0, 0x66, 0xc7, 0xb7, 0x39, 0x8c, 0xdf, 0x1c, 0x6a, 0xb3, 0xb3, - 0x5a, 0xaf, 0x3e, 0x22, 0x1c, 0x9b, 0x98, 0xe3, 0x3f, 0xe2, 0xd7, 0x7c, 0xfb, 0x4a, 0x45, 0x00, - 0x2a, 0x95, 0x10, 0x51, 0xa9, 0xf8, 0x90, 0x66, 0x52, 0x96, 0xfe, 0xf6, 0x5f, 0x01, 0x00, 0x00, - 0xff, 0xff, 0x07, 0xf0, 0xab, 0xae, 0x25, 0x13, 0x00, 0x00, -} - -func (m *ProposalSubmit) 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 *ProposalSubmit) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.DepositAmount != nil { - { - size, err := m.DepositAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Proposal != nil { - { - size, err := m.Proposal.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ProposalWithdraw) 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 *ProposalWithdraw) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Reason) > 0 { - i -= len(m.Reason) - copy(dAtA[i:], m.Reason) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.Reason))) - i-- - dAtA[i] = 0x12 - } - if m.Proposal != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *ProposalDepositClaim) 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 *ProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Outcome != nil { - { - size, err := m.Outcome.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.DepositAmount != nil { - { - size, err := m.DepositAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Proposal != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *ValidatorVote) 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 *ValidatorVote) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.AuthSig != nil { - { - size, err := m.AuthSig.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Body != nil { - { - size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ValidatorVoteBody) 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 *ValidatorVoteBody) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ValidatorVoteBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.GovernanceKey != nil { - { - size, err := m.GovernanceKey.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.IdentityKey != nil { - { - size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Vote != nil { - { - size, err := m.Vote.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Proposal != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *DelegatorVote) 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 *DelegatorVote) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Proof != nil { - { - size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.AuthSig != nil { - { - size, err := m.AuthSig.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Body != nil { - { - size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *DelegatorVoteBody) 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 *DelegatorVoteBody) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DelegatorVoteBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Rk) > 0 { - i -= len(m.Rk) - copy(dAtA[i:], m.Rk) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.Rk))) - i-- - dAtA[i] = 0x3a - } - if len(m.Nullifier) > 0 { - i -= len(m.Nullifier) - copy(dAtA[i:], m.Nullifier) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.Nullifier))) - i-- - dAtA[i] = 0x32 - } - if m.UnbondedAmount != nil { - { - size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - if m.Value != nil { - { - size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.Vote != nil { - { - size, err := m.Vote.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.StartPosition != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.StartPosition)) - i-- - dAtA[i] = 0x10 - } - if m.Proposal != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *DelegatorVotePlan) 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 *DelegatorVotePlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DelegatorVotePlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ProofBlindingS) > 0 { - i -= len(m.ProofBlindingS) - copy(dAtA[i:], m.ProofBlindingS) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.ProofBlindingS))) - i-- - dAtA[i] = 0x4a - } - if len(m.ProofBlindingR) > 0 { - i -= len(m.ProofBlindingR) - copy(dAtA[i:], m.ProofBlindingR) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.ProofBlindingR))) - i-- - dAtA[i] = 0x42 - } - if len(m.Randomizer) > 0 { - i -= len(m.Randomizer) - copy(dAtA[i:], m.Randomizer) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.Randomizer))) - i-- - dAtA[i] = 0x3a - } - if m.UnbondedAmount != nil { - { - size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - if m.StakedNotePosition != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.StakedNotePosition)) - i-- - dAtA[i] = 0x28 - } - if m.StakedNote != nil { - { - size, err := m.StakedNote.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.Vote != nil { - { - size, err := m.Vote.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.StartPosition != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.StartPosition)) - i-- - dAtA[i] = 0x10 - } - if m.Proposal != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.Proposal)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *DaoDeposit) 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 *DaoDeposit) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DaoDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Value != nil { - { - size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *DaoSpend) 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 *DaoSpend) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DaoSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Value != nil { - { - size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *DaoOutput) 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 *DaoOutput) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DaoOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Address != nil { - { - size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Value != nil { - { - size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Vote) 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 *Vote) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Vote != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.Vote)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *ProposalState) 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 *ProposalState) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalState) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.State != nil { - { - size := m.State.Size() - i -= size - if _, err := m.State.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *ProposalState_Voting_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalState_Voting_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Voting != nil { - { - size, err := m.Voting.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *ProposalState_Withdrawn_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalState_Withdrawn_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Withdrawn != nil { - { - size, err := m.Withdrawn.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - return len(dAtA) - i, nil -} -func (m *ProposalState_Finished_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalState_Finished_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Finished != nil { - { - size, err := m.Finished.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - return len(dAtA) - i, nil -} -func (m *ProposalState_Claimed_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalState_Claimed_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Claimed != nil { - { - size, err := m.Claimed.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - return len(dAtA) - i, nil -} -func (m *ProposalState_Voting) 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 *ProposalState_Voting) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalState_Voting) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *ProposalState_Withdrawn) 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 *ProposalState_Withdrawn) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalState_Withdrawn) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Reason) > 0 { - i -= len(m.Reason) - copy(dAtA[i:], m.Reason) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.Reason))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ProposalState_Finished) 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 *ProposalState_Finished) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalState_Finished) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Outcome != nil { - { - size, err := m.Outcome.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ProposalState_Claimed) 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 *ProposalState_Claimed) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalState_Claimed) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Outcome != nil { - { - size, err := m.Outcome.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ProposalOutcome) 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 *ProposalOutcome) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalOutcome) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Outcome != nil { - { - size := m.Outcome.Size() - i -= size - if _, err := m.Outcome.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *ProposalOutcome_Passed_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalOutcome_Passed_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Passed != nil { - { - size, err := m.Passed.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *ProposalOutcome_Failed_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalOutcome_Failed_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Failed != nil { - { - size, err := m.Failed.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *ProposalOutcome_Slashed_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalOutcome_Slashed_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Slashed != nil { - { - size, err := m.Slashed.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - return len(dAtA) - i, nil -} -func (m *ProposalOutcome_Passed) 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 *ProposalOutcome_Passed) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalOutcome_Passed) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *ProposalOutcome_Failed) 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 *ProposalOutcome_Failed) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalOutcome_Failed) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XWithdrawnWithReason != nil { - { - size := m.XWithdrawnWithReason.Size() - i -= size - if _, err := m.XWithdrawnWithReason.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *ProposalOutcome_Failed_WithdrawnWithReason) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalOutcome_Failed_WithdrawnWithReason) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i -= len(m.WithdrawnWithReason) - copy(dAtA[i:], m.WithdrawnWithReason) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.WithdrawnWithReason))) - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} -func (m *ProposalOutcome_Slashed) 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 *ProposalOutcome_Slashed) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalOutcome_Slashed) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XWithdrawnWithReason != nil { - { - size := m.XWithdrawnWithReason.Size() - i -= size - if _, err := m.XWithdrawnWithReason.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *ProposalOutcome_Slashed_WithdrawnWithReason) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ProposalOutcome_Slashed_WithdrawnWithReason) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i -= len(m.WithdrawnWithReason) - copy(dAtA[i:], m.WithdrawnWithReason) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.WithdrawnWithReason))) - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} -func (m *Tally) 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 *Tally) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Tally) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Abstain != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.Abstain)) - i-- - dAtA[i] = 0x18 - } - if m.No != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.No)) - i-- - dAtA[i] = 0x10 - } - if m.Yes != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.Yes)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *Proposal) 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 *Proposal) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.DaoSpend != nil { - { - size, err := m.DaoSpend.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x42 - } - if m.ParameterChange != nil { - { - size, err := m.ParameterChange.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3a - } - if m.Emergency != nil { - { - size, err := m.Emergency.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - if m.Signaling != nil { - { - size, err := m.Signaling.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - if m.Id != 0 { - i = encodeVarintGovernance(dAtA, i, uint64(m.Id)) - i-- - dAtA[i] = 0x20 - } - if len(m.Description) > 0 { - i -= len(m.Description) - copy(dAtA[i:], m.Description) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.Description))) - i-- - dAtA[i] = 0x12 - } - if len(m.Title) > 0 { - i -= len(m.Title) - copy(dAtA[i:], m.Title) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.Title))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Proposal_Signaling) 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 *Proposal_Signaling) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Proposal_Signaling) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XCommit != nil { - { - size := m.XCommit.Size() - i -= size - if _, err := m.XCommit.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *Proposal_Signaling_Commit) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Proposal_Signaling_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i -= len(m.Commit) - copy(dAtA[i:], m.Commit) - i = encodeVarintGovernance(dAtA, i, uint64(len(m.Commit))) - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} -func (m *Proposal_Emergency) 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 *Proposal_Emergency) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Proposal_Emergency) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.HaltChain { - i-- - if m.HaltChain { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *Proposal_ParameterChange) 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 *Proposal_ParameterChange) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Proposal_ParameterChange) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.NewParameters != nil { - { - size, err := m.NewParameters.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.OldParameters != nil { - { - size, err := m.OldParameters.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Proposal_DaoSpend) 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 *Proposal_DaoSpend) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Proposal_DaoSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.TransactionPlan != nil { - { - size, err := m.TransactionPlan.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGovernance(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} - -func encodeVarintGovernance(dAtA []byte, offset int, v uint64) int { - offset -= sovGovernance(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *ProposalSubmit) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Proposal != nil { - l = m.Proposal.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.DepositAmount != nil { - l = m.DepositAmount.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *ProposalWithdraw) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Proposal != 0 { - n += 1 + sovGovernance(uint64(m.Proposal)) - } - l = len(m.Reason) - if l > 0 { - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *ProposalDepositClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Proposal != 0 { - n += 1 + sovGovernance(uint64(m.Proposal)) - } - if m.DepositAmount != nil { - l = m.DepositAmount.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.Outcome != nil { - l = m.Outcome.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *ValidatorVote) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Body != nil { - l = m.Body.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.AuthSig != nil { - l = m.AuthSig.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *ValidatorVoteBody) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Proposal != 0 { - n += 1 + sovGovernance(uint64(m.Proposal)) - } - if m.Vote != nil { - l = m.Vote.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.IdentityKey != nil { - l = m.IdentityKey.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.GovernanceKey != nil { - l = m.GovernanceKey.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *DelegatorVote) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Body != nil { - l = m.Body.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.AuthSig != nil { - l = m.AuthSig.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.Proof != nil { - l = m.Proof.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *DelegatorVoteBody) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Proposal != 0 { - n += 1 + sovGovernance(uint64(m.Proposal)) - } - if m.StartPosition != 0 { - n += 1 + sovGovernance(uint64(m.StartPosition)) - } - if m.Vote != nil { - l = m.Vote.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.Value != nil { - l = m.Value.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.UnbondedAmount != nil { - l = m.UnbondedAmount.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - l = len(m.Nullifier) - if l > 0 { - n += 1 + l + sovGovernance(uint64(l)) - } - l = len(m.Rk) - if l > 0 { - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *DelegatorVotePlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Proposal != 0 { - n += 1 + sovGovernance(uint64(m.Proposal)) - } - if m.StartPosition != 0 { - n += 1 + sovGovernance(uint64(m.StartPosition)) - } - if m.Vote != nil { - l = m.Vote.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.StakedNote != nil { - l = m.StakedNote.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.StakedNotePosition != 0 { - n += 1 + sovGovernance(uint64(m.StakedNotePosition)) - } - if m.UnbondedAmount != nil { - l = m.UnbondedAmount.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - l = len(m.Randomizer) - if l > 0 { - n += 1 + l + sovGovernance(uint64(l)) - } - l = len(m.ProofBlindingR) - if l > 0 { - n += 1 + l + sovGovernance(uint64(l)) - } - l = len(m.ProofBlindingS) - if l > 0 { - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *DaoDeposit) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != nil { - l = m.Value.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *DaoSpend) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != nil { - l = m.Value.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *DaoOutput) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != nil { - l = m.Value.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.Address != nil { - l = m.Address.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *Vote) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Vote != 0 { - n += 1 + sovGovernance(uint64(m.Vote)) - } - return n -} - -func (m *ProposalState) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.State != nil { - n += m.State.Size() - } - return n -} - -func (m *ProposalState_Voting_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Voting != nil { - l = m.Voting.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} -func (m *ProposalState_Withdrawn_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Withdrawn != nil { - l = m.Withdrawn.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} -func (m *ProposalState_Finished_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Finished != nil { - l = m.Finished.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} -func (m *ProposalState_Claimed_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Claimed != nil { - l = m.Claimed.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} -func (m *ProposalState_Voting) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *ProposalState_Withdrawn) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Reason) - if l > 0 { - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *ProposalState_Finished) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Outcome != nil { - l = m.Outcome.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *ProposalState_Claimed) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Outcome != nil { - l = m.Outcome.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *ProposalOutcome) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Outcome != nil { - n += m.Outcome.Size() - } - return n -} - -func (m *ProposalOutcome_Passed_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Passed != nil { - l = m.Passed.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} -func (m *ProposalOutcome_Failed_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Failed != nil { - l = m.Failed.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} -func (m *ProposalOutcome_Slashed_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Slashed != nil { - l = m.Slashed.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} -func (m *ProposalOutcome_Passed) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *ProposalOutcome_Failed) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XWithdrawnWithReason != nil { - n += m.XWithdrawnWithReason.Size() - } - return n -} - -func (m *ProposalOutcome_Failed_WithdrawnWithReason) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.WithdrawnWithReason) - n += 1 + l + sovGovernance(uint64(l)) - return n -} -func (m *ProposalOutcome_Slashed) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XWithdrawnWithReason != nil { - n += m.XWithdrawnWithReason.Size() - } - return n -} - -func (m *ProposalOutcome_Slashed_WithdrawnWithReason) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.WithdrawnWithReason) - n += 1 + l + sovGovernance(uint64(l)) - return n -} -func (m *Tally) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Yes != 0 { - n += 1 + sovGovernance(uint64(m.Yes)) - } - if m.No != 0 { - n += 1 + sovGovernance(uint64(m.No)) - } - if m.Abstain != 0 { - n += 1 + sovGovernance(uint64(m.Abstain)) - } - return n -} - -func (m *Proposal) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Title) - if l > 0 { - n += 1 + l + sovGovernance(uint64(l)) - } - l = len(m.Description) - if l > 0 { - n += 1 + l + sovGovernance(uint64(l)) - } - if m.Id != 0 { - n += 1 + sovGovernance(uint64(m.Id)) - } - if m.Signaling != nil { - l = m.Signaling.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.Emergency != nil { - l = m.Emergency.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.ParameterChange != nil { - l = m.ParameterChange.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.DaoSpend != nil { - l = m.DaoSpend.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *Proposal_Signaling) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XCommit != nil { - n += m.XCommit.Size() - } - return n -} - -func (m *Proposal_Signaling_Commit) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Commit) - n += 1 + l + sovGovernance(uint64(l)) - return n -} -func (m *Proposal_Emergency) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.HaltChain { - n += 2 - } - return n -} - -func (m *Proposal_ParameterChange) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.OldParameters != nil { - l = m.OldParameters.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - if m.NewParameters != nil { - l = m.NewParameters.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func (m *Proposal_DaoSpend) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.TransactionPlan != nil { - l = m.TransactionPlan.Size() - n += 1 + l + sovGovernance(uint64(l)) - } - return n -} - -func sovGovernance(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozGovernance(x uint64) (n int) { - return sovGovernance(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *ProposalSubmit) 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 ErrIntOverflowGovernance - } - 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: ProposalSubmit: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ProposalSubmit: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Proposal == nil { - m.Proposal = &Proposal{} - } - if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DepositAmount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.DepositAmount == nil { - m.DepositAmount = &v1alpha1.Amount{} - } - if err := m.DepositAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalWithdraw) 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 ErrIntOverflowGovernance - } - 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: ProposalWithdraw: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ProposalWithdraw: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) - } - m.Proposal = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Proposal |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - 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 ErrInvalidLengthGovernance - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Reason = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalDepositClaim) 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 ErrIntOverflowGovernance - } - 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: ProposalDepositClaim: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ProposalDepositClaim: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) - } - m.Proposal = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Proposal |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DepositAmount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.DepositAmount == nil { - m.DepositAmount = &v1alpha1.Amount{} - } - if err := m.DepositAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Outcome", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Outcome == nil { - m.Outcome = &ProposalOutcome{} - } - if err := m.Outcome.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ValidatorVote) 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 ErrIntOverflowGovernance - } - 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: ValidatorVote: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ValidatorVote: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Body == nil { - m.Body = &ValidatorVoteBody{} - } - if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.AuthSig == nil { - m.AuthSig = &v1alpha1.SpendAuthSignature{} - } - if err := m.AuthSig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ValidatorVoteBody) 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 ErrIntOverflowGovernance - } - 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: ValidatorVoteBody: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ValidatorVoteBody: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) - } - m.Proposal = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Proposal |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Vote == nil { - m.Vote = &Vote{} - } - if err := m.Vote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.IdentityKey == nil { - m.IdentityKey = &v1alpha1.IdentityKey{} - } - if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GovernanceKey", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.GovernanceKey == nil { - m.GovernanceKey = &v1alpha1.GovernanceKey{} - } - if err := m.GovernanceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DelegatorVote) 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 ErrIntOverflowGovernance - } - 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: DelegatorVote: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DelegatorVote: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Body == nil { - m.Body = &DelegatorVoteBody{} - } - if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.AuthSig == nil { - m.AuthSig = &v1alpha1.SpendAuthSignature{} - } - if err := m.AuthSig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Proof == nil { - m.Proof = &v1alpha1.ZKDelegatorVoteProof{} - } - if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DelegatorVoteBody) 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 ErrIntOverflowGovernance - } - 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: DelegatorVoteBody: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DelegatorVoteBody: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) - } - m.Proposal = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Proposal |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartPosition", wireType) - } - m.StartPosition = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StartPosition |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Vote == nil { - m.Vote = &Vote{} - } - if err := m.Vote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Value == nil { - m.Value = &v1alpha1.Value{} - } - if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.UnbondedAmount == nil { - m.UnbondedAmount = &v1alpha1.Amount{} - } - if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Nullifier = append(m.Nullifier[:0], dAtA[iNdEx:postIndex]...) - if m.Nullifier == nil { - m.Nullifier = []byte{} - } - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Rk", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Rk = append(m.Rk[:0], dAtA[iNdEx:postIndex]...) - if m.Rk == nil { - m.Rk = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DelegatorVotePlan) 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 ErrIntOverflowGovernance - } - 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: DelegatorVotePlan: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DelegatorVotePlan: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) - } - m.Proposal = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Proposal |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartPosition", wireType) - } - m.StartPosition = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StartPosition |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Vote == nil { - m.Vote = &Vote{} - } - if err := m.Vote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StakedNote", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.StakedNote == nil { - m.StakedNote = &v1alpha1.Note{} - } - if err := m.StakedNote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StakedNotePosition", wireType) - } - m.StakedNotePosition = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StakedNotePosition |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.UnbondedAmount == nil { - m.UnbondedAmount = &v1alpha1.Amount{} - } - if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Randomizer", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Randomizer = append(m.Randomizer[:0], dAtA[iNdEx:postIndex]...) - if m.Randomizer == nil { - m.Randomizer = []byte{} - } - iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingR == nil { - m.ProofBlindingR = []byte{} - } - iNdEx = postIndex - case 9: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingS == nil { - m.ProofBlindingS = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DaoDeposit) 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 ErrIntOverflowGovernance - } - 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: DaoDeposit: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DaoDeposit: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Value == nil { - m.Value = &v1alpha1.Value{} - } - if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DaoSpend) 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 ErrIntOverflowGovernance - } - 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: DaoSpend: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DaoSpend: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Value == nil { - m.Value = &v1alpha1.Value{} - } - if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DaoOutput) 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 ErrIntOverflowGovernance - } - 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: DaoOutput: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DaoOutput: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Value == nil { - m.Value = &v1alpha1.Value{} - } - if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Address == nil { - m.Address = &v1alpha1.Address{} - } - if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Vote) 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 ErrIntOverflowGovernance - } - 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: Vote: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Vote: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) - } - m.Vote = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Vote |= Vote_Vote(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalState) 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 ErrIntOverflowGovernance - } - 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: ProposalState: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ProposalState: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Voting", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ProposalState_Voting{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.State = &ProposalState_Voting_{v} - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Withdrawn", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ProposalState_Withdrawn{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.State = &ProposalState_Withdrawn_{v} - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Finished", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ProposalState_Finished{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.State = &ProposalState_Finished_{v} - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Claimed", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ProposalState_Claimed{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.State = &ProposalState_Claimed_{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalState_Voting) 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 ErrIntOverflowGovernance - } - 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: Voting: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Voting: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalState_Withdrawn) 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 ErrIntOverflowGovernance - } - 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: Withdrawn: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Withdrawn: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - 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 ErrInvalidLengthGovernance - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Reason = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalState_Finished) 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 ErrIntOverflowGovernance - } - 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: Finished: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Finished: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Outcome", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Outcome == nil { - m.Outcome = &ProposalOutcome{} - } - if err := m.Outcome.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalState_Claimed) 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 ErrIntOverflowGovernance - } - 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: Claimed: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Claimed: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Outcome", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Outcome == nil { - m.Outcome = &ProposalOutcome{} - } - if err := m.Outcome.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalOutcome) 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 ErrIntOverflowGovernance - } - 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: ProposalOutcome: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ProposalOutcome: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Passed", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ProposalOutcome_Passed{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Outcome = &ProposalOutcome_Passed_{v} - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ProposalOutcome_Failed{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Outcome = &ProposalOutcome_Failed_{v} - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Slashed", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ProposalOutcome_Slashed{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Outcome = &ProposalOutcome_Slashed_{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalOutcome_Passed) 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 ErrIntOverflowGovernance - } - 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: Passed: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Passed: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalOutcome_Failed) 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 ErrIntOverflowGovernance - } - 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: Failed: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Failed: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field WithdrawnWithReason", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - 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 ErrInvalidLengthGovernance - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.XWithdrawnWithReason = &ProposalOutcome_Failed_WithdrawnWithReason{string(dAtA[iNdEx:postIndex])} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ProposalOutcome_Slashed) 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 ErrIntOverflowGovernance - } - 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: Slashed: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Slashed: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field WithdrawnWithReason", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - 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 ErrInvalidLengthGovernance - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.XWithdrawnWithReason = &ProposalOutcome_Slashed_WithdrawnWithReason{string(dAtA[iNdEx:postIndex])} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Tally) 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 ErrIntOverflowGovernance - } - 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: Tally: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Tally: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Yes", wireType) - } - m.Yes = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Yes |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field No", wireType) - } - m.No = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.No |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Abstain", wireType) - } - m.Abstain = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Abstain |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Proposal) 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 ErrIntOverflowGovernance - } - 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: Proposal: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Proposal: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - 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 ErrInvalidLengthGovernance - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Title = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - 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 ErrInvalidLengthGovernance - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Description = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) - } - m.Id = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Id |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signaling", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Signaling == nil { - m.Signaling = &Proposal_Signaling{} - } - if err := m.Signaling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Emergency", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Emergency == nil { - m.Emergency = &Proposal_Emergency{} - } - if err := m.Emergency.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ParameterChange", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ParameterChange == nil { - m.ParameterChange = &Proposal_ParameterChange{} - } - if err := m.ParameterChange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoSpend", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.DaoSpend == nil { - m.DaoSpend = &Proposal_DaoSpend{} - } - if err := m.DaoSpend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Proposal_Signaling) 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 ErrIntOverflowGovernance - } - 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: Signaling: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Signaling: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - 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 ErrInvalidLengthGovernance - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.XCommit = &Proposal_Signaling_Commit{string(dAtA[iNdEx:postIndex])} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Proposal_Emergency) 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 ErrIntOverflowGovernance - } - 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: Emergency: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Emergency: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field HaltChain", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.HaltChain = bool(v != 0) - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Proposal_ParameterChange) 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 ErrIntOverflowGovernance - } - 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: ParameterChange: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ParameterChange: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field OldParameters", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.OldParameters == nil { - m.OldParameters = &v1alpha11.ChainParameters{} - } - if err := m.OldParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NewParameters", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.NewParameters == nil { - m.NewParameters = &v1alpha11.ChainParameters{} - } - if err := m.NewParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Proposal_DaoSpend) 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 ErrIntOverflowGovernance - } - 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: DaoSpend: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DaoSpend: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TransactionPlan", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGovernance - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGovernance - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGovernance - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.TransactionPlan == nil { - m.TransactionPlan = &types.Any{} - } - if err := m.TransactionPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGovernance(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGovernance - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipGovernance(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, ErrIntOverflowGovernance - } - 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, ErrIntOverflowGovernance - } - 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, ErrIntOverflowGovernance - } - 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, ErrInvalidLengthGovernance - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupGovernance - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthGovernance - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthGovernance = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowGovernance = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupGovernance = fmt.Errorf("proto: unexpected end of group") -) diff --git a/relayer/chains/penumbra/core/keys/v1alpha1/keys.pb.go b/relayer/chains/penumbra/core/keys/v1alpha1/keys.pb.go new file mode 100644 index 000000000..f31738fd9 --- /dev/null +++ b/relayer/chains/penumbra/core/keys/v1alpha1/keys.pb.go @@ -0,0 +1,2787 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/keys/v1alpha1/keys.proto + +package keysv1alpha1 + +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 + +// A Penumbra address. An address in Penumbra is a Bech32m-encoded +// string, with the human-readable prefix (HRP) `penumbrav2t`. +type Address struct { + // The bytes of the address. Must be represented as a series of + // `uint8` (i.e. values 0 through 255), with a length of 80 elements. + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` + // Alternatively, a Bech32m-encoded string representation of the `inner` + // bytes. + // + // NOTE: implementations are not required to support parsing this field. + // Implementations should prefer to encode the bytes in all messages they + // produce. Implementations must not accept messages with both `inner` and + // `alt_bech32m` set. + AltBech32M string `protobuf:"bytes,2,opt,name=alt_bech32m,json=altBech32m,proto3" json:"alt_bech32m,omitempty"` +} + +func (m *Address) Reset() { *m = Address{} } +func (m *Address) String() string { return proto.CompactTextString(m) } +func (*Address) ProtoMessage() {} +func (*Address) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{0} +} +func (m *Address) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Address) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Address.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 *Address) XXX_Merge(src proto.Message) { + xxx_messageInfo_Address.Merge(m, src) +} +func (m *Address) XXX_Size() int { + return m.Size() +} +func (m *Address) XXX_DiscardUnknown() { + xxx_messageInfo_Address.DiscardUnknown(m) +} + +var xxx_messageInfo_Address proto.InternalMessageInfo + +func (m *Address) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +func (m *Address) GetAltBech32M() string { + if m != nil { + return m.AltBech32M + } + return "" +} + +type AddressView struct { + // Types that are valid to be assigned to AddressView: + // + // *AddressView_Visible_ + // *AddressView_Opaque_ + AddressView isAddressView_AddressView `protobuf_oneof:"address_view"` +} + +func (m *AddressView) Reset() { *m = AddressView{} } +func (m *AddressView) String() string { return proto.CompactTextString(m) } +func (*AddressView) ProtoMessage() {} +func (*AddressView) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{1} +} +func (m *AddressView) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddressView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddressView.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 *AddressView) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddressView.Merge(m, src) +} +func (m *AddressView) XXX_Size() int { + return m.Size() +} +func (m *AddressView) XXX_DiscardUnknown() { + xxx_messageInfo_AddressView.DiscardUnknown(m) +} + +var xxx_messageInfo_AddressView proto.InternalMessageInfo + +type isAddressView_AddressView interface { + isAddressView_AddressView() + MarshalTo([]byte) (int, error) + Size() int +} + +type AddressView_Visible_ struct { + Visible *AddressView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` +} +type AddressView_Opaque_ struct { + Opaque *AddressView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +} + +func (*AddressView_Visible_) isAddressView_AddressView() {} +func (*AddressView_Opaque_) isAddressView_AddressView() {} + +func (m *AddressView) GetAddressView() isAddressView_AddressView { + if m != nil { + return m.AddressView + } + return nil +} + +func (m *AddressView) GetVisible() *AddressView_Visible { + if x, ok := m.GetAddressView().(*AddressView_Visible_); ok { + return x.Visible + } + return nil +} + +func (m *AddressView) GetOpaque() *AddressView_Opaque { + if x, ok := m.GetAddressView().(*AddressView_Opaque_); ok { + return x.Opaque + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*AddressView) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*AddressView_Visible_)(nil), + (*AddressView_Opaque_)(nil), + } +} + +type AddressView_Visible struct { + Address *Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Index *AddressIndex `protobuf:"bytes,2,opt,name=index,proto3" json:"index,omitempty"` + WalletId *WalletId `protobuf:"bytes,3,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` +} + +func (m *AddressView_Visible) Reset() { *m = AddressView_Visible{} } +func (m *AddressView_Visible) String() string { return proto.CompactTextString(m) } +func (*AddressView_Visible) ProtoMessage() {} +func (*AddressView_Visible) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{1, 0} +} +func (m *AddressView_Visible) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddressView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddressView_Visible.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 *AddressView_Visible) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddressView_Visible.Merge(m, src) +} +func (m *AddressView_Visible) XXX_Size() int { + return m.Size() +} +func (m *AddressView_Visible) XXX_DiscardUnknown() { + xxx_messageInfo_AddressView_Visible.DiscardUnknown(m) +} + +var xxx_messageInfo_AddressView_Visible proto.InternalMessageInfo + +func (m *AddressView_Visible) GetAddress() *Address { + if m != nil { + return m.Address + } + return nil +} + +func (m *AddressView_Visible) GetIndex() *AddressIndex { + if m != nil { + return m.Index + } + return nil +} + +func (m *AddressView_Visible) GetWalletId() *WalletId { + if m != nil { + return m.WalletId + } + return nil +} + +type AddressView_Opaque struct { + Address *Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *AddressView_Opaque) Reset() { *m = AddressView_Opaque{} } +func (m *AddressView_Opaque) String() string { return proto.CompactTextString(m) } +func (*AddressView_Opaque) ProtoMessage() {} +func (*AddressView_Opaque) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{1, 1} +} +func (m *AddressView_Opaque) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddressView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddressView_Opaque.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 *AddressView_Opaque) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddressView_Opaque.Merge(m, src) +} +func (m *AddressView_Opaque) XXX_Size() int { + return m.Size() +} +func (m *AddressView_Opaque) XXX_DiscardUnknown() { + xxx_messageInfo_AddressView_Opaque.DiscardUnknown(m) +} + +var xxx_messageInfo_AddressView_Opaque proto.InternalMessageInfo + +func (m *AddressView_Opaque) GetAddress() *Address { + if m != nil { + return m.Address + } + return nil +} + +type PayloadKey struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *PayloadKey) Reset() { *m = PayloadKey{} } +func (m *PayloadKey) String() string { return proto.CompactTextString(m) } +func (*PayloadKey) ProtoMessage() {} +func (*PayloadKey) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{2} +} +func (m *PayloadKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PayloadKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PayloadKey.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 *PayloadKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_PayloadKey.Merge(m, src) +} +func (m *PayloadKey) XXX_Size() int { + return m.Size() +} +func (m *PayloadKey) XXX_DiscardUnknown() { + xxx_messageInfo_PayloadKey.DiscardUnknown(m) +} + +var xxx_messageInfo_PayloadKey proto.InternalMessageInfo + +func (m *PayloadKey) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +type SpendKey struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *SpendKey) Reset() { *m = SpendKey{} } +func (m *SpendKey) String() string { return proto.CompactTextString(m) } +func (*SpendKey) ProtoMessage() {} +func (*SpendKey) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{3} +} +func (m *SpendKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpendKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpendKey.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 *SpendKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpendKey.Merge(m, src) +} +func (m *SpendKey) XXX_Size() int { + return m.Size() +} +func (m *SpendKey) XXX_DiscardUnknown() { + xxx_messageInfo_SpendKey.DiscardUnknown(m) +} + +var xxx_messageInfo_SpendKey proto.InternalMessageInfo + +func (m *SpendKey) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +type FullViewingKey struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *FullViewingKey) Reset() { *m = FullViewingKey{} } +func (m *FullViewingKey) String() string { return proto.CompactTextString(m) } +func (*FullViewingKey) ProtoMessage() {} +func (*FullViewingKey) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{4} +} +func (m *FullViewingKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FullViewingKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FullViewingKey.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 *FullViewingKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_FullViewingKey.Merge(m, src) +} +func (m *FullViewingKey) XXX_Size() int { + return m.Size() +} +func (m *FullViewingKey) XXX_DiscardUnknown() { + xxx_messageInfo_FullViewingKey.DiscardUnknown(m) +} + +var xxx_messageInfo_FullViewingKey proto.InternalMessageInfo + +func (m *FullViewingKey) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +type WalletId struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *WalletId) Reset() { *m = WalletId{} } +func (m *WalletId) String() string { return proto.CompactTextString(m) } +func (*WalletId) ProtoMessage() {} +func (*WalletId) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{5} +} +func (m *WalletId) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WalletId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WalletId.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 *WalletId) XXX_Merge(src proto.Message) { + xxx_messageInfo_WalletId.Merge(m, src) +} +func (m *WalletId) XXX_Size() int { + return m.Size() +} +func (m *WalletId) XXX_DiscardUnknown() { + xxx_messageInfo_WalletId.DiscardUnknown(m) +} + +var xxx_messageInfo_WalletId proto.InternalMessageInfo + +func (m *WalletId) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +type Diversifier struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *Diversifier) Reset() { *m = Diversifier{} } +func (m *Diversifier) String() string { return proto.CompactTextString(m) } +func (*Diversifier) ProtoMessage() {} +func (*Diversifier) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{6} +} +func (m *Diversifier) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Diversifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Diversifier.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 *Diversifier) XXX_Merge(src proto.Message) { + xxx_messageInfo_Diversifier.Merge(m, src) +} +func (m *Diversifier) XXX_Size() int { + return m.Size() +} +func (m *Diversifier) XXX_DiscardUnknown() { + xxx_messageInfo_Diversifier.DiscardUnknown(m) +} + +var xxx_messageInfo_Diversifier proto.InternalMessageInfo + +func (m *Diversifier) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +type AddressIndex struct { + Account uint32 `protobuf:"varint,2,opt,name=account,proto3" json:"account,omitempty"` + Randomizer []byte `protobuf:"bytes,3,opt,name=randomizer,proto3" json:"randomizer,omitempty"` +} + +func (m *AddressIndex) Reset() { *m = AddressIndex{} } +func (m *AddressIndex) String() string { return proto.CompactTextString(m) } +func (*AddressIndex) ProtoMessage() {} +func (*AddressIndex) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{7} +} +func (m *AddressIndex) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddressIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddressIndex.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 *AddressIndex) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddressIndex.Merge(m, src) +} +func (m *AddressIndex) XXX_Size() int { + return m.Size() +} +func (m *AddressIndex) XXX_DiscardUnknown() { + xxx_messageInfo_AddressIndex.DiscardUnknown(m) +} + +var xxx_messageInfo_AddressIndex proto.InternalMessageInfo + +func (m *AddressIndex) GetAccount() uint32 { + if m != nil { + return m.Account + } + return 0 +} + +func (m *AddressIndex) GetRandomizer() []byte { + if m != nil { + return m.Randomizer + } + return nil +} + +// A validator's identity key (decaf377-rdsa spendauth verification key). +type IdentityKey struct { + Ik []byte `protobuf:"bytes,1,opt,name=ik,proto3" json:"ik,omitempty"` +} + +func (m *IdentityKey) Reset() { *m = IdentityKey{} } +func (m *IdentityKey) String() string { return proto.CompactTextString(m) } +func (*IdentityKey) ProtoMessage() {} +func (*IdentityKey) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{8} +} +func (m *IdentityKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *IdentityKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_IdentityKey.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 *IdentityKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_IdentityKey.Merge(m, src) +} +func (m *IdentityKey) XXX_Size() int { + return m.Size() +} +func (m *IdentityKey) XXX_DiscardUnknown() { + xxx_messageInfo_IdentityKey.DiscardUnknown(m) +} + +var xxx_messageInfo_IdentityKey proto.InternalMessageInfo + +func (m *IdentityKey) GetIk() []byte { + if m != nil { + return m.Ik + } + return nil +} + +// A validator's governance key (decaf377-rdsa spendauth verification key). +type GovernanceKey struct { + Gk []byte `protobuf:"bytes,1,opt,name=gk,proto3" json:"gk,omitempty"` +} + +func (m *GovernanceKey) Reset() { *m = GovernanceKey{} } +func (m *GovernanceKey) String() string { return proto.CompactTextString(m) } +func (*GovernanceKey) ProtoMessage() {} +func (*GovernanceKey) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{9} +} +func (m *GovernanceKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GovernanceKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GovernanceKey.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 *GovernanceKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_GovernanceKey.Merge(m, src) +} +func (m *GovernanceKey) XXX_Size() int { + return m.Size() +} +func (m *GovernanceKey) XXX_DiscardUnknown() { + xxx_messageInfo_GovernanceKey.DiscardUnknown(m) +} + +var xxx_messageInfo_GovernanceKey proto.InternalMessageInfo + +func (m *GovernanceKey) GetGk() []byte { + if m != nil { + return m.Gk + } + return nil +} + +type ConsensusKey struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *ConsensusKey) Reset() { *m = ConsensusKey{} } +func (m *ConsensusKey) String() string { return proto.CompactTextString(m) } +func (*ConsensusKey) ProtoMessage() {} +func (*ConsensusKey) Descriptor() ([]byte, []int) { + return fileDescriptor_1a822d221e23f7f7, []int{10} +} +func (m *ConsensusKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConsensusKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConsensusKey.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 *ConsensusKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConsensusKey.Merge(m, src) +} +func (m *ConsensusKey) XXX_Size() int { + return m.Size() +} +func (m *ConsensusKey) XXX_DiscardUnknown() { + xxx_messageInfo_ConsensusKey.DiscardUnknown(m) +} + +var xxx_messageInfo_ConsensusKey proto.InternalMessageInfo + +func (m *ConsensusKey) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +func init() { + proto.RegisterType((*Address)(nil), "penumbra.core.keys.v1alpha1.Address") + proto.RegisterType((*AddressView)(nil), "penumbra.core.keys.v1alpha1.AddressView") + proto.RegisterType((*AddressView_Visible)(nil), "penumbra.core.keys.v1alpha1.AddressView.Visible") + proto.RegisterType((*AddressView_Opaque)(nil), "penumbra.core.keys.v1alpha1.AddressView.Opaque") + proto.RegisterType((*PayloadKey)(nil), "penumbra.core.keys.v1alpha1.PayloadKey") + proto.RegisterType((*SpendKey)(nil), "penumbra.core.keys.v1alpha1.SpendKey") + proto.RegisterType((*FullViewingKey)(nil), "penumbra.core.keys.v1alpha1.FullViewingKey") + proto.RegisterType((*WalletId)(nil), "penumbra.core.keys.v1alpha1.WalletId") + proto.RegisterType((*Diversifier)(nil), "penumbra.core.keys.v1alpha1.Diversifier") + proto.RegisterType((*AddressIndex)(nil), "penumbra.core.keys.v1alpha1.AddressIndex") + proto.RegisterType((*IdentityKey)(nil), "penumbra.core.keys.v1alpha1.IdentityKey") + proto.RegisterType((*GovernanceKey)(nil), "penumbra.core.keys.v1alpha1.GovernanceKey") + proto.RegisterType((*ConsensusKey)(nil), "penumbra.core.keys.v1alpha1.ConsensusKey") +} + +func init() { + proto.RegisterFile("penumbra/core/keys/v1alpha1/keys.proto", fileDescriptor_1a822d221e23f7f7) +} + +var fileDescriptor_1a822d221e23f7f7 = []byte{ + // 590 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xcf, 0x6e, 0xd3, 0x4e, + 0x10, 0xc7, 0x63, 0x57, 0xbf, 0xa6, 0x9d, 0xa4, 0x3d, 0x58, 0xbf, 0x43, 0xd4, 0x0a, 0xb7, 0x32, + 0xa5, 0x94, 0x8b, 0x4d, 0xd3, 0x5b, 0x90, 0xf8, 0x93, 0x22, 0x9a, 0xa8, 0x20, 0x22, 0x83, 0x8a, + 0x84, 0x22, 0x55, 0x1b, 0x7b, 0x48, 0x56, 0xb1, 0x77, 0xc3, 0xae, 0xed, 0x60, 0x9e, 0x82, 0x67, + 0xe0, 0x06, 0x4f, 0x82, 0x38, 0xa0, 0x72, 0xe3, 0x88, 0xd2, 0x1b, 0x4f, 0x81, 0xd6, 0x7f, 0x4a, + 0x0f, 0xd4, 0xaa, 0xc4, 0x6d, 0x67, 0xe7, 0xf3, 0xfd, 0xce, 0xcc, 0xae, 0xbd, 0xb0, 0x3b, 0x43, + 0x16, 0x87, 0x23, 0x41, 0x1c, 0x8f, 0x0b, 0x74, 0xa6, 0x98, 0x4a, 0x27, 0xd9, 0x27, 0xc1, 0x6c, + 0x42, 0xf6, 0xb3, 0xc8, 0x9e, 0x09, 0x1e, 0x71, 0x63, 0xb3, 0xe4, 0x6c, 0xc5, 0xd9, 0x59, 0xa6, + 0xe4, 0xac, 0x87, 0x50, 0x7f, 0xe4, 0xfb, 0x02, 0xa5, 0x34, 0xfe, 0x87, 0xff, 0x28, 0x63, 0x28, + 0x5a, 0xda, 0xb6, 0xb6, 0xd7, 0x74, 0xf3, 0xc0, 0xd8, 0x82, 0x06, 0x09, 0xa2, 0xd3, 0x11, 0x7a, + 0x93, 0x83, 0x76, 0xd8, 0xd2, 0xb7, 0xb5, 0xbd, 0x55, 0x17, 0x48, 0x10, 0x75, 0xf3, 0x1d, 0xeb, + 0xfb, 0x12, 0x34, 0x0a, 0x8b, 0x13, 0x8a, 0x73, 0xe3, 0x29, 0xd4, 0x13, 0x2a, 0xe9, 0x28, 0xc0, + 0xcc, 0xa8, 0xd1, 0xbe, 0x6b, 0x57, 0x34, 0x60, 0x5f, 0x92, 0xda, 0x27, 0xb9, 0xae, 0x57, 0x73, + 0x4b, 0x0b, 0xa3, 0x0f, 0xcb, 0x7c, 0x46, 0xde, 0xc6, 0x98, 0x55, 0x6e, 0xb4, 0x9d, 0x6b, 0x9b, + 0x3d, 0xcf, 0x64, 0xbd, 0x9a, 0x5b, 0x18, 0x6c, 0x7c, 0xd3, 0xa0, 0x5e, 0x54, 0x30, 0xee, 0x43, + 0x9d, 0xe4, 0x6c, 0xd1, 0xe4, 0xce, 0x75, 0x7c, 0xdd, 0x52, 0x64, 0x3c, 0x50, 0x67, 0xe5, 0xe3, + 0xbb, 0xa2, 0xab, 0x3b, 0xd7, 0x51, 0xf7, 0x95, 0xc0, 0xcd, 0x75, 0x46, 0x17, 0x56, 0xe7, 0x24, + 0x08, 0x30, 0x3a, 0xa5, 0x7e, 0x6b, 0x29, 0x33, 0xb9, 0x55, 0x69, 0xf2, 0x2a, 0xa3, 0xfb, 0xbe, + 0xbb, 0x32, 0x2f, 0x56, 0x1b, 0x3d, 0x58, 0xce, 0x87, 0xfc, 0xd7, 0x71, 0xba, 0xeb, 0xd0, 0x2c, + 0x96, 0xa7, 0x09, 0xc5, 0xb9, 0x65, 0x01, 0x0c, 0x48, 0x1a, 0x70, 0xe2, 0x1f, 0x63, 0xfa, 0xf7, + 0x0f, 0xc3, 0xda, 0x86, 0x95, 0x17, 0x33, 0x64, 0x15, 0xc4, 0x2e, 0xac, 0x3f, 0x89, 0x83, 0x40, + 0xdd, 0x06, 0x65, 0xe3, 0x4a, 0xa7, 0x72, 0xba, 0x2b, 0x88, 0x9b, 0xd0, 0x78, 0x4c, 0x13, 0x14, + 0x92, 0xbe, 0xa1, 0x28, 0xae, 0x80, 0x7a, 0xd0, 0xbc, 0x7c, 0xd2, 0x46, 0x0b, 0xea, 0xc4, 0xf3, + 0x78, 0xcc, 0xa2, 0xec, 0x96, 0xd6, 0xdc, 0x32, 0x34, 0x4c, 0x00, 0x41, 0x98, 0xcf, 0x43, 0xfa, + 0x1e, 0x45, 0x76, 0xfa, 0x4d, 0xf7, 0xd2, 0x8e, 0x75, 0x03, 0x1a, 0x7d, 0x1f, 0x59, 0x44, 0xa3, + 0x54, 0x75, 0xbd, 0x0e, 0x3a, 0x9d, 0x16, 0xb5, 0x74, 0x3a, 0xb5, 0xb6, 0x60, 0xed, 0x88, 0x27, + 0x28, 0x18, 0x61, 0x1e, 0x16, 0xc0, 0xf8, 0x02, 0x18, 0x4f, 0xad, 0x1d, 0x68, 0x1e, 0x72, 0x26, + 0x91, 0xc9, 0x58, 0x5e, 0x39, 0x76, 0xf7, 0x93, 0xfe, 0x65, 0x61, 0x6a, 0x67, 0x0b, 0x53, 0xfb, + 0xb9, 0x30, 0xb5, 0x0f, 0xe7, 0x66, 0xed, 0xec, 0xdc, 0xac, 0xfd, 0x38, 0x37, 0x6b, 0xb0, 0xe5, + 0xf1, 0xb0, 0xea, 0x06, 0xbb, 0xab, 0xc7, 0x98, 0xca, 0x81, 0xfa, 0xbd, 0x07, 0xda, 0xeb, 0x97, + 0x63, 0x1a, 0x4d, 0xe2, 0x91, 0xed, 0xf1, 0xd0, 0xf1, 0xb8, 0x0c, 0xb9, 0x74, 0x04, 0x06, 0x24, + 0x45, 0xe1, 0x24, 0xed, 0x8b, 0xa5, 0x37, 0x21, 0x94, 0x49, 0xa7, 0xe2, 0xd1, 0xb8, 0xa7, 0xa2, + 0x32, 0xf8, 0xa8, 0x2f, 0x0d, 0x0e, 0x8f, 0x3f, 0xeb, 0x9b, 0x83, 0xb2, 0x8d, 0x43, 0xd5, 0x86, + 0xaa, 0x6b, 0x9f, 0x14, 0xcc, 0xd7, 0x3f, 0xd9, 0xa1, 0xca, 0x0e, 0x55, 0x76, 0x58, 0x66, 0x17, + 0xfa, 0xed, 0x8a, 0xec, 0xf0, 0x68, 0xd0, 0x7d, 0x86, 0x11, 0xf1, 0x49, 0x44, 0x7e, 0xe9, 0x66, + 0x49, 0x76, 0x3a, 0x0a, 0xed, 0x74, 0x14, 0xdb, 0xe9, 0x94, 0xf0, 0x68, 0x39, 0x7b, 0xca, 0x0e, + 0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x5e, 0xb3, 0x0c, 0xd4, 0xf4, 0x04, 0x00, 0x00, +} + +func (m *Address) 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 *Address) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Address) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AltBech32M) > 0 { + i -= len(m.AltBech32M) + copy(dAtA[i:], m.AltBech32M) + i = encodeVarintKeys(dAtA, i, uint64(len(m.AltBech32M))) + i-- + dAtA[i] = 0x12 + } + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AddressView) 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 *AddressView) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddressView) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AddressView != nil { + { + size := m.AddressView.Size() + i -= size + if _, err := m.AddressView.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *AddressView_Visible_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddressView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Visible != nil { + { + size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeys(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *AddressView_Opaque_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddressView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Opaque != nil { + { + size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeys(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *AddressView_Visible) 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 *AddressView_Visible) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddressView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.WalletId != nil { + { + size, err := m.WalletId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeys(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Index != nil { + { + size, err := m.Index.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeys(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Address != nil { + { + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeys(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AddressView_Opaque) 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 *AddressView_Opaque) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddressView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Address != nil { + { + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintKeys(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PayloadKey) 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 *PayloadKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PayloadKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SpendKey) 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 *SpendKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *FullViewingKey) 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 *FullViewingKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FullViewingKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *WalletId) 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 *WalletId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WalletId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Diversifier) 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 *Diversifier) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Diversifier) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AddressIndex) 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 *AddressIndex) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddressIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Randomizer) > 0 { + i -= len(m.Randomizer) + copy(dAtA[i:], m.Randomizer) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Randomizer))) + i-- + dAtA[i] = 0x1a + } + if m.Account != 0 { + i = encodeVarintKeys(dAtA, i, uint64(m.Account)) + i-- + dAtA[i] = 0x10 + } + return len(dAtA) - i, nil +} + +func (m *IdentityKey) 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 *IdentityKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *IdentityKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ik) > 0 { + i -= len(m.Ik) + copy(dAtA[i:], m.Ik) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Ik))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GovernanceKey) 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 *GovernanceKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GovernanceKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Gk) > 0 { + i -= len(m.Gk) + copy(dAtA[i:], m.Gk) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Gk))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ConsensusKey) 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 *ConsensusKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConsensusKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintKeys(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintKeys(dAtA []byte, offset int, v uint64) int { + offset -= sovKeys(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Address) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + l = len(m.AltBech32M) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *AddressView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AddressView != nil { + n += m.AddressView.Size() + } + return n +} + +func (m *AddressView_Visible_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Visible != nil { + l = m.Visible.Size() + n += 1 + l + sovKeys(uint64(l)) + } + return n +} +func (m *AddressView_Opaque_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Opaque != nil { + l = m.Opaque.Size() + n += 1 + l + sovKeys(uint64(l)) + } + return n +} +func (m *AddressView_Visible) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Address != nil { + l = m.Address.Size() + n += 1 + l + sovKeys(uint64(l)) + } + if m.Index != nil { + l = m.Index.Size() + n += 1 + l + sovKeys(uint64(l)) + } + if m.WalletId != nil { + l = m.WalletId.Size() + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *AddressView_Opaque) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Address != nil { + l = m.Address.Size() + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *PayloadKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *SpendKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *FullViewingKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *WalletId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *Diversifier) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *AddressIndex) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Account != 0 { + n += 1 + sovKeys(uint64(m.Account)) + } + l = len(m.Randomizer) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *IdentityKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Ik) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *GovernanceKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Gk) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func (m *ConsensusKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovKeys(uint64(l)) + } + return n +} + +func sovKeys(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozKeys(x uint64) (n int) { + return sovKeys(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Address) 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 ErrIntOverflowKeys + } + 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: Address: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Address: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AltBech32M", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + 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 ErrInvalidLengthKeys + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AltBech32M = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AddressView) 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 ErrIntOverflowKeys + } + 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: AddressView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AddressView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &AddressView_Visible{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AddressView = &AddressView_Visible_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &AddressView_Opaque{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AddressView = &AddressView_Opaque_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AddressView_Visible) 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 ErrIntOverflowKeys + } + 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: Visible: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &AddressIndex{} + } + if err := m.Index.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WalletId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WalletId == nil { + m.WalletId = &WalletId{} + } + if err := m.WalletId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AddressView_Opaque) 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 ErrIntOverflowKeys + } + 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: Opaque: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PayloadKey) 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 ErrIntOverflowKeys + } + 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: PayloadKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PayloadKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpendKey) 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 ErrIntOverflowKeys + } + 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: SpendKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpendKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FullViewingKey) 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 ErrIntOverflowKeys + } + 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: FullViewingKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FullViewingKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WalletId) 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 ErrIntOverflowKeys + } + 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: WalletId: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WalletId: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Diversifier) 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 ErrIntOverflowKeys + } + 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: Diversifier: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Diversifier: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AddressIndex) 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 ErrIntOverflowKeys + } + 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: AddressIndex: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AddressIndex: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType) + } + m.Account = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Account |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Randomizer", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Randomizer = append(m.Randomizer[:0], dAtA[iNdEx:postIndex]...) + if m.Randomizer == nil { + m.Randomizer = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IdentityKey) 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 ErrIntOverflowKeys + } + 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: IdentityKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IdentityKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ik", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ik = append(m.Ik[:0], dAtA[iNdEx:postIndex]...) + if m.Ik == nil { + m.Ik = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GovernanceKey) 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 ErrIntOverflowKeys + } + 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: GovernanceKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GovernanceKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Gk", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Gk = append(m.Gk[:0], dAtA[iNdEx:postIndex]...) + if m.Gk == nil { + m.Gk = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConsensusKey) 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 ErrIntOverflowKeys + } + 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: ConsensusKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConsensusKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKeys + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKeys + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKeys + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipKeys(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthKeys + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipKeys(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, ErrIntOverflowKeys + } + 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, ErrIntOverflowKeys + } + 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, ErrIntOverflowKeys + } + 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, ErrInvalidLengthKeys + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupKeys + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthKeys + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthKeys = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowKeys = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupKeys = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/num/v1alpha1/num.pb.go b/relayer/chains/penumbra/core/num/v1alpha1/num.pb.go new file mode 100644 index 000000000..d4613a05e --- /dev/null +++ b/relayer/chains/penumbra/core/num/v1alpha1/num.pb.go @@ -0,0 +1,348 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/num/v1alpha1/num.proto + +package numv1alpha1 + +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 + +// The quantity of a particular Asset. Represented as a 128-bit unsigned integer, +// split over two fields, `lo` and `hi`, representing the low- and high-order bytes +// of the 128-bit value, respectively. Clients must assemble these bits in their +// implementation into a `uint128` or comparable data structure, in order to model +// the Amount accurately. +type Amount struct { + Lo uint64 `protobuf:"varint,1,opt,name=lo,proto3" json:"lo,omitempty"` + Hi uint64 `protobuf:"varint,2,opt,name=hi,proto3" json:"hi,omitempty"` +} + +func (m *Amount) Reset() { *m = Amount{} } +func (m *Amount) String() string { return proto.CompactTextString(m) } +func (*Amount) ProtoMessage() {} +func (*Amount) Descriptor() ([]byte, []int) { + return fileDescriptor_a515e4f6cefdd105, []int{0} +} +func (m *Amount) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Amount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Amount.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 *Amount) XXX_Merge(src proto.Message) { + xxx_messageInfo_Amount.Merge(m, src) +} +func (m *Amount) XXX_Size() int { + return m.Size() +} +func (m *Amount) XXX_DiscardUnknown() { + xxx_messageInfo_Amount.DiscardUnknown(m) +} + +var xxx_messageInfo_Amount proto.InternalMessageInfo + +func (m *Amount) GetLo() uint64 { + if m != nil { + return m.Lo + } + return 0 +} + +func (m *Amount) GetHi() uint64 { + if m != nil { + return m.Hi + } + return 0 +} + +func init() { + proto.RegisterType((*Amount)(nil), "penumbra.core.num.v1alpha1.Amount") +} + +func init() { + proto.RegisterFile("penumbra/core/num/v1alpha1/num.proto", fileDescriptor_a515e4f6cefdd105) +} + +var fileDescriptor_a515e4f6cefdd105 = []byte{ + // 277 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0x31, 0x4b, 0xc4, 0x30, + 0x18, 0x86, 0x9b, 0x28, 0x87, 0x74, 0x70, 0xb8, 0xe9, 0x38, 0x30, 0x88, 0x88, 0xdc, 0x94, 0x70, + 0xba, 0xc5, 0xc9, 0xde, 0xe0, 0x64, 0x29, 0x37, 0x38, 0x48, 0x97, 0xb4, 0x16, 0x5b, 0xe8, 0xd7, + 0xaf, 0xa4, 0xc9, 0x81, 0xff, 0xc2, 0xbf, 0xa0, 0xa3, 0xbf, 0x44, 0x9c, 0x6e, 0x74, 0x94, 0x76, + 0xf3, 0x57, 0x48, 0xd4, 0x78, 0x53, 0xb7, 0xf7, 0xe5, 0x79, 0x20, 0x6f, 0xbe, 0xf0, 0xb4, 0x2d, + 0x1a, 0x0b, 0x99, 0x56, 0x22, 0x47, 0x5d, 0x88, 0xc6, 0x82, 0xd8, 0x2c, 0x55, 0xdd, 0x96, 0x6a, + 0xe9, 0x0a, 0x6f, 0x35, 0x1a, 0x9c, 0xce, 0xbd, 0xc5, 0x9d, 0xc5, 0x1d, 0xf0, 0xd6, 0xc9, 0x22, + 0x9c, 0x5c, 0x01, 0xda, 0xc6, 0x4c, 0x0f, 0x43, 0x5a, 0xe3, 0x8c, 0x1c, 0x93, 0xc5, 0xfe, 0x9a, + 0xd6, 0xe8, 0x7a, 0x59, 0xcd, 0xe8, 0x6f, 0x2f, 0xab, 0xe8, 0x99, 0xbe, 0xf5, 0x8c, 0x6c, 0x7b, + 0x46, 0x3e, 0x7b, 0x46, 0x9e, 0x06, 0x16, 0x6c, 0x07, 0x16, 0x7c, 0x0c, 0x2c, 0x08, 0x59, 0x8e, + 0xc0, 0xc7, 0x1f, 0x89, 0x0e, 0x62, 0x0b, 0x89, 0x9b, 0x92, 0x90, 0xbb, 0xf5, 0x43, 0x65, 0x4a, + 0x9b, 0xf1, 0x1c, 0x41, 0xe4, 0xd8, 0x01, 0x76, 0x42, 0x17, 0xb5, 0x7a, 0x2c, 0xb4, 0xd8, 0x9c, + 0xff, 0xc7, 0xbc, 0x54, 0x55, 0xd3, 0x89, 0xf1, 0xef, 0x5d, 0x36, 0x16, 0x7c, 0x7e, 0xa1, 0x7b, + 0xc9, 0x2a, 0x7e, 0xa5, 0xf3, 0xc4, 0x4f, 0x58, 0xb9, 0x09, 0xb1, 0x05, 0x7e, 0xfb, 0xa7, 0xbc, + 0xef, 0x60, 0xea, 0x60, 0x1a, 0x5b, 0x48, 0x3d, 0xec, 0xe9, 0xd9, 0x38, 0x4c, 0xaf, 0x93, 0xe8, + 0xa6, 0x30, 0xea, 0x5e, 0x19, 0xf5, 0x45, 0x8f, 0xbc, 0x28, 0xa5, 0x33, 0xa5, 0x8c, 0x2d, 0x48, + 0xe9, 0xdd, 0x6c, 0xf2, 0x73, 0xf0, 0x8b, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbb, 0x55, 0x25, + 0xb1, 0x98, 0x01, 0x00, 0x00, +} + +func (m *Amount) 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 *Amount) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Amount) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Hi != 0 { + i = encodeVarintNum(dAtA, i, uint64(m.Hi)) + i-- + dAtA[i] = 0x10 + } + if m.Lo != 0 { + i = encodeVarintNum(dAtA, i, uint64(m.Lo)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintNum(dAtA []byte, offset int, v uint64) int { + offset -= sovNum(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Amount) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Lo != 0 { + n += 1 + sovNum(uint64(m.Lo)) + } + if m.Hi != 0 { + n += 1 + sovNum(uint64(m.Hi)) + } + return n +} + +func sovNum(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozNum(x uint64) (n int) { + return sovNum(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Amount) 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 ErrIntOverflowNum + } + 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: Amount: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Amount: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Lo", wireType) + } + m.Lo = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNum + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Lo |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Hi", wireType) + } + m.Hi = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNum + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Hi |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipNum(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNum + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipNum(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, ErrIntOverflowNum + } + 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, ErrIntOverflowNum + } + 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, ErrIntOverflowNum + } + 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, ErrInvalidLengthNum + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupNum + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthNum + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthNum = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowNum = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupNum = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/core/transaction/v1alpha1/transaction.pb.go b/relayer/chains/penumbra/core/transaction/v1alpha1/transaction.pb.go index c22d6f2ae..0c4272ed9 100644 --- a/relayer/chains/penumbra/core/transaction/v1alpha1/transaction.pb.go +++ b/relayer/chains/penumbra/core/transaction/v1alpha1/transaction.pb.go @@ -6,11 +6,19 @@ package transactionv1alpha1 import ( fmt "fmt" proto "github.com/cosmos/gogoproto/proto" - v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" - v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/dex/v1alpha1" - v1alpha14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/governance/v1alpha1" - v1alpha13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/ibc/v1alpha1" - v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/stake/v1alpha1" + v1alpha110 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + v1alpha15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/dex/v1alpha1" + v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1alpha1" + v1alpha18 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/governance/v1alpha1" + v1alpha17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1alpha1" + v1alpha112 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1alpha1" + v1alpha14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1alpha1" + v1alpha16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1alpha1" + v1alpha19 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1" + v1alpha111 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/txhash/v1alpha1" + v1alpha13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_fmd/v1alpha1" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_rdsa/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1alpha1" io "io" math "math" math_bits "math/bits" @@ -31,10 +39,10 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Transaction struct { Body *TransactionBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` // The binding signature is stored separately from the transaction body that it signs. - BindingSig []byte `protobuf:"bytes,2,opt,name=binding_sig,json=bindingSig,proto3" json:"binding_sig,omitempty"` + BindingSig *v1alpha1.BindingSignature `protobuf:"bytes,2,opt,name=binding_sig,json=bindingSig,proto3" json:"binding_sig,omitempty"` // The root of some previous state of the state commitment tree, used as an anchor for all // ZK state transition proofs. - Anchor *v1alpha1.MerkleRoot `protobuf:"bytes,3,opt,name=anchor,proto3" json:"anchor,omitempty"` + Anchor *v1alpha11.MerkleRoot `protobuf:"bytes,3,opt,name=anchor,proto3" json:"anchor,omitempty"` } func (m *Transaction) Reset() { *m = Transaction{} } @@ -77,128 +85,39 @@ func (m *Transaction) GetBody() *TransactionBody { return nil } -func (m *Transaction) GetBindingSig() []byte { +func (m *Transaction) GetBindingSig() *v1alpha1.BindingSignature { if m != nil { return m.BindingSig } return nil } -func (m *Transaction) GetAnchor() *v1alpha1.MerkleRoot { +func (m *Transaction) GetAnchor() *v1alpha11.MerkleRoot { if m != nil { return m.Anchor } return nil } -// A transaction ID, the Sha256 hash of a transaction. -type Id struct { - Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` -} - -func (m *Id) Reset() { *m = Id{} } -func (m *Id) String() string { return proto.CompactTextString(m) } -func (*Id) ProtoMessage() {} -func (*Id) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{1} -} -func (m *Id) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Id) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Id.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 *Id) XXX_Merge(src proto.Message) { - xxx_messageInfo_Id.Merge(m, src) -} -func (m *Id) XXX_Size() int { - return m.Size() -} -func (m *Id) XXX_DiscardUnknown() { - xxx_messageInfo_Id.DiscardUnknown(m) -} - -var xxx_messageInfo_Id proto.InternalMessageInfo - -func (m *Id) GetHash() []byte { - if m != nil { - return m.Hash - } - return nil -} - -type EffectHash struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *EffectHash) Reset() { *m = EffectHash{} } -func (m *EffectHash) String() string { return proto.CompactTextString(m) } -func (*EffectHash) ProtoMessage() {} -func (*EffectHash) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{2} -} -func (m *EffectHash) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *EffectHash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_EffectHash.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 *EffectHash) XXX_Merge(src proto.Message) { - xxx_messageInfo_EffectHash.Merge(m, src) -} -func (m *EffectHash) XXX_Size() int { - return m.Size() -} -func (m *EffectHash) XXX_DiscardUnknown() { - xxx_messageInfo_EffectHash.DiscardUnknown(m) -} - -var xxx_messageInfo_EffectHash proto.InternalMessageInfo - -func (m *EffectHash) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - // The body of a transaction. type TransactionBody struct { // A list of actions (state changes) performed by this transaction. Actions []*Action `protobuf:"bytes,1,rep,name=actions,proto3" json:"actions,omitempty"` // Parameters determining if a transaction should be accepted by this chain. TransactionParameters *TransactionParameters `protobuf:"bytes,2,opt,name=transaction_parameters,json=transactionParameters,proto3" json:"transaction_parameters,omitempty"` - // The transaction fee. - Fee *v1alpha1.Fee `protobuf:"bytes,3,opt,name=fee,proto3" json:"fee,omitempty"` // Detection data for use with Fuzzy Message Detection DetectionData *DetectionData `protobuf:"bytes,4,opt,name=detection_data,json=detectionData,proto3" json:"detection_data,omitempty"` - // Sub-message containing memo ciphertext if a memo was added to the transaction. - MemoData *MemoData `protobuf:"bytes,5,opt,name=memo_data,json=memoData,proto3" json:"memo_data,omitempty"` + // The encrypted memo for this transaction. + // + // This field will be present if and only if the transaction has outputs. + Memo *MemoCiphertext `protobuf:"bytes,5,opt,name=memo,proto3" json:"memo,omitempty"` } func (m *TransactionBody) Reset() { *m = TransactionBody{} } func (m *TransactionBody) String() string { return proto.CompactTextString(m) } func (*TransactionBody) ProtoMessage() {} func (*TransactionBody) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{3} + return fileDescriptor_cd20ea79758052c4, []int{1} } func (m *TransactionBody) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -241,13 +160,6 @@ func (m *TransactionBody) GetTransactionParameters() *TransactionParameters { return nil } -func (m *TransactionBody) GetFee() *v1alpha1.Fee { - if m != nil { - return m.Fee - } - return nil -} - func (m *TransactionBody) GetDetectionData() *DetectionData { if m != nil { return m.DetectionData @@ -255,86 +167,13 @@ func (m *TransactionBody) GetDetectionData() *DetectionData { return nil } -func (m *TransactionBody) GetMemoData() *MemoData { - if m != nil { - return m.MemoData - } - return nil -} - -// Represents the encrypted memo data. -type MemoData struct { - // Types that are valid to be assigned to XEncryptedMemo: - // *MemoData_EncryptedMemo - XEncryptedMemo isMemoData_XEncryptedMemo `protobuf_oneof:"_encrypted_memo"` -} - -func (m *MemoData) Reset() { *m = MemoData{} } -func (m *MemoData) String() string { return proto.CompactTextString(m) } -func (*MemoData) ProtoMessage() {} -func (*MemoData) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{4} -} -func (m *MemoData) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MemoData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MemoData.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 *MemoData) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemoData.Merge(m, src) -} -func (m *MemoData) XXX_Size() int { - return m.Size() -} -func (m *MemoData) XXX_DiscardUnknown() { - xxx_messageInfo_MemoData.DiscardUnknown(m) -} - -var xxx_messageInfo_MemoData proto.InternalMessageInfo - -type isMemoData_XEncryptedMemo interface { - isMemoData_XEncryptedMemo() - MarshalTo([]byte) (int, error) - Size() int -} - -type MemoData_EncryptedMemo struct { - EncryptedMemo []byte `protobuf:"bytes,1,opt,name=encrypted_memo,json=encryptedMemo,proto3,oneof" json:"encrypted_memo,omitempty"` -} - -func (*MemoData_EncryptedMemo) isMemoData_XEncryptedMemo() {} - -func (m *MemoData) GetXEncryptedMemo() isMemoData_XEncryptedMemo { +func (m *TransactionBody) GetMemo() *MemoCiphertext { if m != nil { - return m.XEncryptedMemo - } - return nil -} - -func (m *MemoData) GetEncryptedMemo() []byte { - if x, ok := m.GetXEncryptedMemo().(*MemoData_EncryptedMemo); ok { - return x.EncryptedMemo + return m.Memo } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*MemoData) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*MemoData_EncryptedMemo)(nil), - } -} - // The parameters determining if a transaction should be accepted by the chain. type TransactionParameters struct { // The maximum height that this transaction can be included in the chain. @@ -344,13 +183,15 @@ type TransactionParameters struct { // The chain this transaction is intended for. Including this prevents // replaying a transaction on one chain onto a different chain. ChainId string `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The transaction fee. + Fee *v1alpha12.Fee `protobuf:"bytes,3,opt,name=fee,proto3" json:"fee,omitempty"` } func (m *TransactionParameters) Reset() { *m = TransactionParameters{} } func (m *TransactionParameters) String() string { return proto.CompactTextString(m) } func (*TransactionParameters) ProtoMessage() {} func (*TransactionParameters) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{5} + return fileDescriptor_cd20ea79758052c4, []int{2} } func (m *TransactionParameters) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -393,17 +234,24 @@ func (m *TransactionParameters) GetChainId() string { return "" } +func (m *TransactionParameters) GetFee() *v1alpha12.Fee { + if m != nil { + return m.Fee + } + return nil +} + // Detection data used by a detection server performing Fuzzy Message Detection. type DetectionData struct { // A list of clues for use with Fuzzy Message Detection. - FmdClues []*v1alpha1.Clue `protobuf:"bytes,4,rep,name=fmd_clues,json=fmdClues,proto3" json:"fmd_clues,omitempty"` + FmdClues []*v1alpha13.Clue `protobuf:"bytes,4,rep,name=fmd_clues,json=fmdClues,proto3" json:"fmd_clues,omitempty"` } func (m *DetectionData) Reset() { *m = DetectionData{} } func (m *DetectionData) String() string { return proto.CompactTextString(m) } func (*DetectionData) ProtoMessage() {} func (*DetectionData) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{6} + return fileDescriptor_cd20ea79758052c4, []int{3} } func (m *DetectionData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -432,7 +280,7 @@ func (m *DetectionData) XXX_DiscardUnknown() { var xxx_messageInfo_DetectionData proto.InternalMessageInfo -func (m *DetectionData) GetFmdClues() []*v1alpha1.Clue { +func (m *DetectionData) GetFmdClues() []*v1alpha13.Clue { if m != nil { return m.FmdClues } @@ -447,7 +295,7 @@ type Action struct { // *Action_Swap // *Action_SwapClaim // *Action_ValidatorDefinition - // *Action_IbcAction + // *Action_IbcRelayAction // *Action_ProposalSubmit // *Action_ProposalWithdraw // *Action_ValidatorVote @@ -460,9 +308,9 @@ type Action struct { // *Action_Delegate // *Action_Undelegate // *Action_UndelegateClaim - // *Action_DaoSpend - // *Action_DaoOutput - // *Action_DaoDeposit + // *Action_CommunityPoolSpend + // *Action_CommunityPoolOutput + // *Action_CommunityPoolDeposit // *Action_Ics20Withdrawal Action isAction_Action `protobuf_oneof:"action"` } @@ -471,7 +319,7 @@ func (m *Action) Reset() { *m = Action{} } func (m *Action) String() string { return proto.CompactTextString(m) } func (*Action) ProtoMessage() {} func (*Action) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{7} + return fileDescriptor_cd20ea79758052c4, []int{4} } func (m *Action) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -507,70 +355,70 @@ type isAction_Action interface { } type Action_Spend struct { - Spend *Spend `protobuf:"bytes,1,opt,name=spend,proto3,oneof" json:"spend,omitempty"` + Spend *v1alpha14.Spend `protobuf:"bytes,1,opt,name=spend,proto3,oneof" json:"spend,omitempty"` } type Action_Output struct { - Output *Output `protobuf:"bytes,2,opt,name=output,proto3,oneof" json:"output,omitempty"` + Output *v1alpha14.Output `protobuf:"bytes,2,opt,name=output,proto3,oneof" json:"output,omitempty"` } type Action_Swap struct { - Swap *v1alpha11.Swap `protobuf:"bytes,3,opt,name=swap,proto3,oneof" json:"swap,omitempty"` + Swap *v1alpha15.Swap `protobuf:"bytes,3,opt,name=swap,proto3,oneof" json:"swap,omitempty"` } type Action_SwapClaim struct { - SwapClaim *v1alpha11.SwapClaim `protobuf:"bytes,4,opt,name=swap_claim,json=swapClaim,proto3,oneof" json:"swap_claim,omitempty"` + SwapClaim *v1alpha15.SwapClaim `protobuf:"bytes,4,opt,name=swap_claim,json=swapClaim,proto3,oneof" json:"swap_claim,omitempty"` } type Action_ValidatorDefinition struct { - ValidatorDefinition *v1alpha12.ValidatorDefinition `protobuf:"bytes,16,opt,name=validator_definition,json=validatorDefinition,proto3,oneof" json:"validator_definition,omitempty"` + ValidatorDefinition *v1alpha16.ValidatorDefinition `protobuf:"bytes,16,opt,name=validator_definition,json=validatorDefinition,proto3,oneof" json:"validator_definition,omitempty"` } -type Action_IbcAction struct { - IbcAction *v1alpha13.IbcAction `protobuf:"bytes,17,opt,name=ibc_action,json=ibcAction,proto3,oneof" json:"ibc_action,omitempty"` +type Action_IbcRelayAction struct { + IbcRelayAction *v1alpha17.IbcRelay `protobuf:"bytes,17,opt,name=ibc_relay_action,json=ibcRelayAction,proto3,oneof" json:"ibc_relay_action,omitempty"` } type Action_ProposalSubmit struct { - ProposalSubmit *v1alpha14.ProposalSubmit `protobuf:"bytes,18,opt,name=proposal_submit,json=proposalSubmit,proto3,oneof" json:"proposal_submit,omitempty"` + ProposalSubmit *v1alpha18.ProposalSubmit `protobuf:"bytes,18,opt,name=proposal_submit,json=proposalSubmit,proto3,oneof" json:"proposal_submit,omitempty"` } type Action_ProposalWithdraw struct { - ProposalWithdraw *v1alpha14.ProposalWithdraw `protobuf:"bytes,19,opt,name=proposal_withdraw,json=proposalWithdraw,proto3,oneof" json:"proposal_withdraw,omitempty"` + ProposalWithdraw *v1alpha18.ProposalWithdraw `protobuf:"bytes,19,opt,name=proposal_withdraw,json=proposalWithdraw,proto3,oneof" json:"proposal_withdraw,omitempty"` } type Action_ValidatorVote struct { - ValidatorVote *v1alpha14.ValidatorVote `protobuf:"bytes,20,opt,name=validator_vote,json=validatorVote,proto3,oneof" json:"validator_vote,omitempty"` + ValidatorVote *v1alpha18.ValidatorVote `protobuf:"bytes,20,opt,name=validator_vote,json=validatorVote,proto3,oneof" json:"validator_vote,omitempty"` } type Action_DelegatorVote struct { - DelegatorVote *v1alpha14.DelegatorVote `protobuf:"bytes,21,opt,name=delegator_vote,json=delegatorVote,proto3,oneof" json:"delegator_vote,omitempty"` + DelegatorVote *v1alpha18.DelegatorVote `protobuf:"bytes,21,opt,name=delegator_vote,json=delegatorVote,proto3,oneof" json:"delegator_vote,omitempty"` } type Action_ProposalDepositClaim struct { - ProposalDepositClaim *v1alpha14.ProposalDepositClaim `protobuf:"bytes,22,opt,name=proposal_deposit_claim,json=proposalDepositClaim,proto3,oneof" json:"proposal_deposit_claim,omitempty"` + ProposalDepositClaim *v1alpha18.ProposalDepositClaim `protobuf:"bytes,22,opt,name=proposal_deposit_claim,json=proposalDepositClaim,proto3,oneof" json:"proposal_deposit_claim,omitempty"` } type Action_PositionOpen struct { - PositionOpen *v1alpha11.PositionOpen `protobuf:"bytes,30,opt,name=position_open,json=positionOpen,proto3,oneof" json:"position_open,omitempty"` + PositionOpen *v1alpha15.PositionOpen `protobuf:"bytes,30,opt,name=position_open,json=positionOpen,proto3,oneof" json:"position_open,omitempty"` } type Action_PositionClose struct { - PositionClose *v1alpha11.PositionClose `protobuf:"bytes,31,opt,name=position_close,json=positionClose,proto3,oneof" json:"position_close,omitempty"` + PositionClose *v1alpha15.PositionClose `protobuf:"bytes,31,opt,name=position_close,json=positionClose,proto3,oneof" json:"position_close,omitempty"` } type Action_PositionWithdraw struct { - PositionWithdraw *v1alpha11.PositionWithdraw `protobuf:"bytes,32,opt,name=position_withdraw,json=positionWithdraw,proto3,oneof" json:"position_withdraw,omitempty"` + PositionWithdraw *v1alpha15.PositionWithdraw `protobuf:"bytes,32,opt,name=position_withdraw,json=positionWithdraw,proto3,oneof" json:"position_withdraw,omitempty"` } type Action_PositionRewardClaim struct { - PositionRewardClaim *v1alpha11.PositionRewardClaim `protobuf:"bytes,34,opt,name=position_reward_claim,json=positionRewardClaim,proto3,oneof" json:"position_reward_claim,omitempty"` + PositionRewardClaim *v1alpha15.PositionRewardClaim `protobuf:"bytes,34,opt,name=position_reward_claim,json=positionRewardClaim,proto3,oneof" json:"position_reward_claim,omitempty"` } type Action_Delegate struct { - Delegate *v1alpha12.Delegate `protobuf:"bytes,40,opt,name=delegate,proto3,oneof" json:"delegate,omitempty"` + Delegate *v1alpha16.Delegate `protobuf:"bytes,40,opt,name=delegate,proto3,oneof" json:"delegate,omitempty"` } type Action_Undelegate struct { - Undelegate *v1alpha12.Undelegate `protobuf:"bytes,41,opt,name=undelegate,proto3,oneof" json:"undelegate,omitempty"` + Undelegate *v1alpha16.Undelegate `protobuf:"bytes,41,opt,name=undelegate,proto3,oneof" json:"undelegate,omitempty"` } type Action_UndelegateClaim struct { - UndelegateClaim *v1alpha12.UndelegateClaim `protobuf:"bytes,42,opt,name=undelegate_claim,json=undelegateClaim,proto3,oneof" json:"undelegate_claim,omitempty"` + UndelegateClaim *v1alpha16.UndelegateClaim `protobuf:"bytes,42,opt,name=undelegate_claim,json=undelegateClaim,proto3,oneof" json:"undelegate_claim,omitempty"` } -type Action_DaoSpend struct { - DaoSpend *v1alpha14.DaoSpend `protobuf:"bytes,50,opt,name=dao_spend,json=daoSpend,proto3,oneof" json:"dao_spend,omitempty"` +type Action_CommunityPoolSpend struct { + CommunityPoolSpend *v1alpha18.CommunityPoolSpend `protobuf:"bytes,50,opt,name=community_pool_spend,json=communityPoolSpend,proto3,oneof" json:"community_pool_spend,omitempty"` } -type Action_DaoOutput struct { - DaoOutput *v1alpha14.DaoOutput `protobuf:"bytes,51,opt,name=dao_output,json=daoOutput,proto3,oneof" json:"dao_output,omitempty"` +type Action_CommunityPoolOutput struct { + CommunityPoolOutput *v1alpha18.CommunityPoolOutput `protobuf:"bytes,51,opt,name=community_pool_output,json=communityPoolOutput,proto3,oneof" json:"community_pool_output,omitempty"` } -type Action_DaoDeposit struct { - DaoDeposit *v1alpha14.DaoDeposit `protobuf:"bytes,52,opt,name=dao_deposit,json=daoDeposit,proto3,oneof" json:"dao_deposit,omitempty"` +type Action_CommunityPoolDeposit struct { + CommunityPoolDeposit *v1alpha18.CommunityPoolDeposit `protobuf:"bytes,52,opt,name=community_pool_deposit,json=communityPoolDeposit,proto3,oneof" json:"community_pool_deposit,omitempty"` } type Action_Ics20Withdrawal struct { - Ics20Withdrawal *v1alpha13.Ics20Withdrawal `protobuf:"bytes,200,opt,name=ics20_withdrawal,json=ics20Withdrawal,proto3,oneof" json:"ics20_withdrawal,omitempty"` + Ics20Withdrawal *v1alpha17.Ics20Withdrawal `protobuf:"bytes,200,opt,name=ics20_withdrawal,json=ics20Withdrawal,proto3,oneof" json:"ics20_withdrawal,omitempty"` } func (*Action_Spend) isAction_Action() {} @@ -578,7 +426,7 @@ func (*Action_Output) isAction_Action() {} func (*Action_Swap) isAction_Action() {} func (*Action_SwapClaim) isAction_Action() {} func (*Action_ValidatorDefinition) isAction_Action() {} -func (*Action_IbcAction) isAction_Action() {} +func (*Action_IbcRelayAction) isAction_Action() {} func (*Action_ProposalSubmit) isAction_Action() {} func (*Action_ProposalWithdraw) isAction_Action() {} func (*Action_ValidatorVote) isAction_Action() {} @@ -591,9 +439,9 @@ func (*Action_PositionRewardClaim) isAction_Action() {} func (*Action_Delegate) isAction_Action() {} func (*Action_Undelegate) isAction_Action() {} func (*Action_UndelegateClaim) isAction_Action() {} -func (*Action_DaoSpend) isAction_Action() {} -func (*Action_DaoOutput) isAction_Action() {} -func (*Action_DaoDeposit) isAction_Action() {} +func (*Action_CommunityPoolSpend) isAction_Action() {} +func (*Action_CommunityPoolOutput) isAction_Action() {} +func (*Action_CommunityPoolDeposit) isAction_Action() {} func (*Action_Ics20Withdrawal) isAction_Action() {} func (m *Action) GetAction() isAction_Action { @@ -603,154 +451,154 @@ func (m *Action) GetAction() isAction_Action { return nil } -func (m *Action) GetSpend() *Spend { +func (m *Action) GetSpend() *v1alpha14.Spend { if x, ok := m.GetAction().(*Action_Spend); ok { return x.Spend } return nil } -func (m *Action) GetOutput() *Output { +func (m *Action) GetOutput() *v1alpha14.Output { if x, ok := m.GetAction().(*Action_Output); ok { return x.Output } return nil } -func (m *Action) GetSwap() *v1alpha11.Swap { +func (m *Action) GetSwap() *v1alpha15.Swap { if x, ok := m.GetAction().(*Action_Swap); ok { return x.Swap } return nil } -func (m *Action) GetSwapClaim() *v1alpha11.SwapClaim { +func (m *Action) GetSwapClaim() *v1alpha15.SwapClaim { if x, ok := m.GetAction().(*Action_SwapClaim); ok { return x.SwapClaim } return nil } -func (m *Action) GetValidatorDefinition() *v1alpha12.ValidatorDefinition { +func (m *Action) GetValidatorDefinition() *v1alpha16.ValidatorDefinition { if x, ok := m.GetAction().(*Action_ValidatorDefinition); ok { return x.ValidatorDefinition } return nil } -func (m *Action) GetIbcAction() *v1alpha13.IbcAction { - if x, ok := m.GetAction().(*Action_IbcAction); ok { - return x.IbcAction +func (m *Action) GetIbcRelayAction() *v1alpha17.IbcRelay { + if x, ok := m.GetAction().(*Action_IbcRelayAction); ok { + return x.IbcRelayAction } return nil } -func (m *Action) GetProposalSubmit() *v1alpha14.ProposalSubmit { +func (m *Action) GetProposalSubmit() *v1alpha18.ProposalSubmit { if x, ok := m.GetAction().(*Action_ProposalSubmit); ok { return x.ProposalSubmit } return nil } -func (m *Action) GetProposalWithdraw() *v1alpha14.ProposalWithdraw { +func (m *Action) GetProposalWithdraw() *v1alpha18.ProposalWithdraw { if x, ok := m.GetAction().(*Action_ProposalWithdraw); ok { return x.ProposalWithdraw } return nil } -func (m *Action) GetValidatorVote() *v1alpha14.ValidatorVote { +func (m *Action) GetValidatorVote() *v1alpha18.ValidatorVote { if x, ok := m.GetAction().(*Action_ValidatorVote); ok { return x.ValidatorVote } return nil } -func (m *Action) GetDelegatorVote() *v1alpha14.DelegatorVote { +func (m *Action) GetDelegatorVote() *v1alpha18.DelegatorVote { if x, ok := m.GetAction().(*Action_DelegatorVote); ok { return x.DelegatorVote } return nil } -func (m *Action) GetProposalDepositClaim() *v1alpha14.ProposalDepositClaim { +func (m *Action) GetProposalDepositClaim() *v1alpha18.ProposalDepositClaim { if x, ok := m.GetAction().(*Action_ProposalDepositClaim); ok { return x.ProposalDepositClaim } return nil } -func (m *Action) GetPositionOpen() *v1alpha11.PositionOpen { +func (m *Action) GetPositionOpen() *v1alpha15.PositionOpen { if x, ok := m.GetAction().(*Action_PositionOpen); ok { return x.PositionOpen } return nil } -func (m *Action) GetPositionClose() *v1alpha11.PositionClose { +func (m *Action) GetPositionClose() *v1alpha15.PositionClose { if x, ok := m.GetAction().(*Action_PositionClose); ok { return x.PositionClose } return nil } -func (m *Action) GetPositionWithdraw() *v1alpha11.PositionWithdraw { +func (m *Action) GetPositionWithdraw() *v1alpha15.PositionWithdraw { if x, ok := m.GetAction().(*Action_PositionWithdraw); ok { return x.PositionWithdraw } return nil } -func (m *Action) GetPositionRewardClaim() *v1alpha11.PositionRewardClaim { +func (m *Action) GetPositionRewardClaim() *v1alpha15.PositionRewardClaim { if x, ok := m.GetAction().(*Action_PositionRewardClaim); ok { return x.PositionRewardClaim } return nil } -func (m *Action) GetDelegate() *v1alpha12.Delegate { +func (m *Action) GetDelegate() *v1alpha16.Delegate { if x, ok := m.GetAction().(*Action_Delegate); ok { return x.Delegate } return nil } -func (m *Action) GetUndelegate() *v1alpha12.Undelegate { +func (m *Action) GetUndelegate() *v1alpha16.Undelegate { if x, ok := m.GetAction().(*Action_Undelegate); ok { return x.Undelegate } return nil } -func (m *Action) GetUndelegateClaim() *v1alpha12.UndelegateClaim { +func (m *Action) GetUndelegateClaim() *v1alpha16.UndelegateClaim { if x, ok := m.GetAction().(*Action_UndelegateClaim); ok { return x.UndelegateClaim } return nil } -func (m *Action) GetDaoSpend() *v1alpha14.DaoSpend { - if x, ok := m.GetAction().(*Action_DaoSpend); ok { - return x.DaoSpend +func (m *Action) GetCommunityPoolSpend() *v1alpha18.CommunityPoolSpend { + if x, ok := m.GetAction().(*Action_CommunityPoolSpend); ok { + return x.CommunityPoolSpend } return nil } -func (m *Action) GetDaoOutput() *v1alpha14.DaoOutput { - if x, ok := m.GetAction().(*Action_DaoOutput); ok { - return x.DaoOutput +func (m *Action) GetCommunityPoolOutput() *v1alpha18.CommunityPoolOutput { + if x, ok := m.GetAction().(*Action_CommunityPoolOutput); ok { + return x.CommunityPoolOutput } return nil } -func (m *Action) GetDaoDeposit() *v1alpha14.DaoDeposit { - if x, ok := m.GetAction().(*Action_DaoDeposit); ok { - return x.DaoDeposit +func (m *Action) GetCommunityPoolDeposit() *v1alpha18.CommunityPoolDeposit { + if x, ok := m.GetAction().(*Action_CommunityPoolDeposit); ok { + return x.CommunityPoolDeposit } return nil } -func (m *Action) GetIcs20Withdrawal() *v1alpha13.Ics20Withdrawal { +func (m *Action) GetIcs20Withdrawal() *v1alpha17.Ics20Withdrawal { if x, ok := m.GetAction().(*Action_Ics20Withdrawal); ok { return x.Ics20Withdrawal } @@ -765,7 +613,7 @@ func (*Action) XXX_OneofWrappers() []interface{} { (*Action_Swap)(nil), (*Action_SwapClaim)(nil), (*Action_ValidatorDefinition)(nil), - (*Action_IbcAction)(nil), + (*Action_IbcRelayAction)(nil), (*Action_ProposalSubmit)(nil), (*Action_ProposalWithdraw)(nil), (*Action_ValidatorVote)(nil), @@ -778,9 +626,9 @@ func (*Action) XXX_OneofWrappers() []interface{} { (*Action_Delegate)(nil), (*Action_Undelegate)(nil), (*Action_UndelegateClaim)(nil), - (*Action_DaoSpend)(nil), - (*Action_DaoOutput)(nil), - (*Action_DaoDeposit)(nil), + (*Action_CommunityPoolSpend)(nil), + (*Action_CommunityPoolOutput)(nil), + (*Action_CommunityPoolDeposit)(nil), (*Action_Ics20Withdrawal)(nil), } } @@ -792,20 +640,20 @@ type TransactionPerspective struct { SpendNullifiers []*NullifierWithNote `protobuf:"bytes,2,rep,name=spend_nullifiers,json=spendNullifiers,proto3" json:"spend_nullifiers,omitempty"` // The openings of note commitments referred to in the transaction // but not included in the transaction. - AdviceNotes []*v1alpha1.Note `protobuf:"bytes,3,rep,name=advice_notes,json=adviceNotes,proto3" json:"advice_notes,omitempty"` + AdviceNotes []*v1alpha14.Note `protobuf:"bytes,3,rep,name=advice_notes,json=adviceNotes,proto3" json:"advice_notes,omitempty"` // Any relevant address views. - AddressViews []*v1alpha1.AddressView `protobuf:"bytes,4,rep,name=address_views,json=addressViews,proto3" json:"address_views,omitempty"` + AddressViews []*v1alpha19.AddressView `protobuf:"bytes,4,rep,name=address_views,json=addressViews,proto3" json:"address_views,omitempty"` // Any relevant denoms for viewed assets. - Denoms []*v1alpha1.DenomMetadata `protobuf:"bytes,5,rep,name=denoms,proto3" json:"denoms,omitempty"` + Denoms []*v1alpha110.DenomMetadata `protobuf:"bytes,5,rep,name=denoms,proto3" json:"denoms,omitempty"` // The transaction ID associated with this TransactionPerspective - TransactionId *Id `protobuf:"bytes,6,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"` + TransactionId *v1alpha111.TransactionId `protobuf:"bytes,6,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"` } func (m *TransactionPerspective) Reset() { *m = TransactionPerspective{} } func (m *TransactionPerspective) String() string { return proto.CompactTextString(m) } func (*TransactionPerspective) ProtoMessage() {} func (*TransactionPerspective) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{8} + return fileDescriptor_cd20ea79758052c4, []int{5} } func (m *TransactionPerspective) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -848,88 +696,44 @@ func (m *TransactionPerspective) GetSpendNullifiers() []*NullifierWithNote { return nil } -func (m *TransactionPerspective) GetAdviceNotes() []*v1alpha1.Note { +func (m *TransactionPerspective) GetAdviceNotes() []*v1alpha14.Note { if m != nil { return m.AdviceNotes } return nil } -func (m *TransactionPerspective) GetAddressViews() []*v1alpha1.AddressView { +func (m *TransactionPerspective) GetAddressViews() []*v1alpha19.AddressView { if m != nil { return m.AddressViews } return nil } -func (m *TransactionPerspective) GetDenoms() []*v1alpha1.DenomMetadata { +func (m *TransactionPerspective) GetDenoms() []*v1alpha110.DenomMetadata { if m != nil { return m.Denoms } return nil } -func (m *TransactionPerspective) GetTransactionId() *Id { +func (m *TransactionPerspective) GetTransactionId() *v1alpha111.TransactionId { if m != nil { return m.TransactionId } return nil } -type PayloadKey struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` -} - -func (m *PayloadKey) Reset() { *m = PayloadKey{} } -func (m *PayloadKey) String() string { return proto.CompactTextString(m) } -func (*PayloadKey) ProtoMessage() {} -func (*PayloadKey) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{9} -} -func (m *PayloadKey) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PayloadKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_PayloadKey.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 *PayloadKey) XXX_Merge(src proto.Message) { - xxx_messageInfo_PayloadKey.Merge(m, src) -} -func (m *PayloadKey) XXX_Size() int { - return m.Size() -} -func (m *PayloadKey) XXX_DiscardUnknown() { - xxx_messageInfo_PayloadKey.DiscardUnknown(m) -} - -var xxx_messageInfo_PayloadKey proto.InternalMessageInfo - -func (m *PayloadKey) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} - type PayloadKeyWithCommitment struct { - PayloadKey *PayloadKey `protobuf:"bytes,1,opt,name=payload_key,json=payloadKey,proto3" json:"payload_key,omitempty"` - Commitment *v1alpha1.StateCommitment `protobuf:"bytes,2,opt,name=commitment,proto3" json:"commitment,omitempty"` + PayloadKey *v1alpha19.PayloadKey `protobuf:"bytes,1,opt,name=payload_key,json=payloadKey,proto3" json:"payload_key,omitempty"` + Commitment *v1alpha11.StateCommitment `protobuf:"bytes,2,opt,name=commitment,proto3" json:"commitment,omitempty"` } func (m *PayloadKeyWithCommitment) Reset() { *m = PayloadKeyWithCommitment{} } func (m *PayloadKeyWithCommitment) String() string { return proto.CompactTextString(m) } func (*PayloadKeyWithCommitment) ProtoMessage() {} func (*PayloadKeyWithCommitment) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{10} + return fileDescriptor_cd20ea79758052c4, []int{6} } func (m *PayloadKeyWithCommitment) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -958,14 +762,14 @@ func (m *PayloadKeyWithCommitment) XXX_DiscardUnknown() { var xxx_messageInfo_PayloadKeyWithCommitment proto.InternalMessageInfo -func (m *PayloadKeyWithCommitment) GetPayloadKey() *PayloadKey { +func (m *PayloadKeyWithCommitment) GetPayloadKey() *v1alpha19.PayloadKey { if m != nil { return m.PayloadKey } return nil } -func (m *PayloadKeyWithCommitment) GetCommitment() *v1alpha1.StateCommitment { +func (m *PayloadKeyWithCommitment) GetCommitment() *v1alpha11.StateCommitment { if m != nil { return m.Commitment } @@ -973,15 +777,15 @@ func (m *PayloadKeyWithCommitment) GetCommitment() *v1alpha1.StateCommitment { } type NullifierWithNote struct { - Nullifier *v1alpha1.Nullifier `protobuf:"bytes,1,opt,name=nullifier,proto3" json:"nullifier,omitempty"` - Note *v1alpha1.Note `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` + Nullifier *v1alpha112.Nullifier `protobuf:"bytes,1,opt,name=nullifier,proto3" json:"nullifier,omitempty"` + Note *v1alpha14.Note `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` } func (m *NullifierWithNote) Reset() { *m = NullifierWithNote{} } func (m *NullifierWithNote) String() string { return proto.CompactTextString(m) } func (*NullifierWithNote) ProtoMessage() {} func (*NullifierWithNote) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{11} + return fileDescriptor_cd20ea79758052c4, []int{7} } func (m *NullifierWithNote) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1010,14 +814,14 @@ func (m *NullifierWithNote) XXX_DiscardUnknown() { var xxx_messageInfo_NullifierWithNote proto.InternalMessageInfo -func (m *NullifierWithNote) GetNullifier() *v1alpha1.Nullifier { +func (m *NullifierWithNote) GetNullifier() *v1alpha112.Nullifier { if m != nil { return m.Nullifier } return nil } -func (m *NullifierWithNote) GetNote() *v1alpha1.Note { +func (m *NullifierWithNote) GetNote() *v1alpha14.Note { if m != nil { return m.Note } @@ -1029,17 +833,17 @@ type TransactionView struct { // View of the transaction body BodyView *TransactionBodyView `protobuf:"bytes,1,opt,name=body_view,json=bodyView,proto3" json:"body_view,omitempty"` // The binding signature is stored separately from the transaction body that it signs. - BindingSig []byte `protobuf:"bytes,2,opt,name=binding_sig,json=bindingSig,proto3" json:"binding_sig,omitempty"` + BindingSig *v1alpha1.BindingSignature `protobuf:"bytes,2,opt,name=binding_sig,json=bindingSig,proto3" json:"binding_sig,omitempty"` // The root of some previous state of the state commitment tree, used as an anchor for all // ZK state transition proofs. - Anchor *v1alpha1.MerkleRoot `protobuf:"bytes,3,opt,name=anchor,proto3" json:"anchor,omitempty"` + Anchor *v1alpha11.MerkleRoot `protobuf:"bytes,3,opt,name=anchor,proto3" json:"anchor,omitempty"` } func (m *TransactionView) Reset() { *m = TransactionView{} } func (m *TransactionView) String() string { return proto.CompactTextString(m) } func (*TransactionView) ProtoMessage() {} func (*TransactionView) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{12} + return fileDescriptor_cd20ea79758052c4, []int{8} } func (m *TransactionView) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1075,14 +879,14 @@ func (m *TransactionView) GetBodyView() *TransactionBodyView { return nil } -func (m *TransactionView) GetBindingSig() []byte { +func (m *TransactionView) GetBindingSig() *v1alpha1.BindingSignature { if m != nil { return m.BindingSig } return nil } -func (m *TransactionView) GetAnchor() *v1alpha1.MerkleRoot { +func (m *TransactionView) GetAnchor() *v1alpha11.MerkleRoot { if m != nil { return m.Anchor } @@ -1094,23 +898,19 @@ type TransactionBodyView struct { ActionViews []*ActionView `protobuf:"bytes,1,rep,name=action_views,json=actionViews,proto3" json:"action_views,omitempty"` // Transaction parameters. TransactionParameters *TransactionParameters `protobuf:"bytes,2,opt,name=transaction_parameters,json=transactionParameters,proto3" json:"transaction_parameters,omitempty"` - // The transaction fee. - Fee *v1alpha1.Fee `protobuf:"bytes,3,opt,name=fee,proto3" json:"fee,omitempty"` - // Types that are valid to be assigned to XDetectionData: - // - // *TransactionBodyView_DetectionData - XDetectionData isTransactionBodyView_XDetectionData `protobuf_oneof:"_detection_data"` - // Types that are valid to be assigned to XMemoView: - // - // *TransactionBodyView_MemoView - XMemoView isTransactionBodyView_XMemoView `protobuf_oneof:"_memo_view"` + // The detection data in this transaction, only populated if + // there are outputs in the actions of this transaction. + DetectionData *DetectionData `protobuf:"bytes,4,opt,name=detection_data,json=detectionData,proto3" json:"detection_data,omitempty"` + // An optional view of a transaction memo. It will only be populated if there are + // outputs in the actions of this transaction. + MemoView *MemoView `protobuf:"bytes,5,opt,name=memo_view,json=memoView,proto3" json:"memo_view,omitempty"` } func (m *TransactionBodyView) Reset() { *m = TransactionBodyView{} } func (m *TransactionBodyView) String() string { return proto.CompactTextString(m) } func (*TransactionBodyView) ProtoMessage() {} func (*TransactionBodyView) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{13} + return fileDescriptor_cd20ea79758052c4, []int{9} } func (m *TransactionBodyView) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1139,40 +939,6 @@ func (m *TransactionBodyView) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionBodyView proto.InternalMessageInfo -type isTransactionBodyView_XDetectionData interface { - isTransactionBodyView_XDetectionData() - MarshalTo([]byte) (int, error) - Size() int -} -type isTransactionBodyView_XMemoView interface { - isTransactionBodyView_XMemoView() - MarshalTo([]byte) (int, error) - Size() int -} - -type TransactionBodyView_DetectionData struct { - DetectionData *DetectionData `protobuf:"bytes,4,opt,name=detection_data,json=detectionData,proto3,oneof" json:"detection_data,omitempty"` -} -type TransactionBodyView_MemoView struct { - MemoView *MemoView `protobuf:"bytes,5,opt,name=memo_view,json=memoView,proto3,oneof" json:"memo_view,omitempty"` -} - -func (*TransactionBodyView_DetectionData) isTransactionBodyView_XDetectionData() {} -func (*TransactionBodyView_MemoView) isTransactionBodyView_XMemoView() {} - -func (m *TransactionBodyView) GetXDetectionData() isTransactionBodyView_XDetectionData { - if m != nil { - return m.XDetectionData - } - return nil -} -func (m *TransactionBodyView) GetXMemoView() isTransactionBodyView_XMemoView { - if m != nil { - return m.XMemoView - } - return nil -} - func (m *TransactionBodyView) GetActionViews() []*ActionView { if m != nil { return m.ActionViews @@ -1187,45 +953,29 @@ func (m *TransactionBodyView) GetTransactionParameters() *TransactionParameters return nil } -func (m *TransactionBodyView) GetFee() *v1alpha1.Fee { - if m != nil { - return m.Fee - } - return nil -} - func (m *TransactionBodyView) GetDetectionData() *DetectionData { - if x, ok := m.GetXDetectionData().(*TransactionBodyView_DetectionData); ok { - return x.DetectionData + if m != nil { + return m.DetectionData } return nil } func (m *TransactionBodyView) GetMemoView() *MemoView { - if x, ok := m.GetXMemoView().(*TransactionBodyView_MemoView); ok { - return x.MemoView + if m != nil { + return m.MemoView } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*TransactionBodyView) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*TransactionBodyView_DetectionData)(nil), - (*TransactionBodyView_MemoView)(nil), - } -} - // A view of a specific state change action performed by a transaction. type ActionView struct { // Types that are valid to be assigned to ActionView: - // // *ActionView_Spend // *ActionView_Output // *ActionView_Swap // *ActionView_SwapClaim // *ActionView_ValidatorDefinition - // *ActionView_IbcAction + // *ActionView_IbcRelayAction // *ActionView_ProposalSubmit // *ActionView_ProposalWithdraw // *ActionView_ValidatorVote @@ -1237,9 +987,9 @@ type ActionView struct { // *ActionView_PositionRewardClaim // *ActionView_Delegate // *ActionView_Undelegate - // *ActionView_DaoSpend - // *ActionView_DaoOutput - // *ActionView_DaoDeposit + // *ActionView_CommunityPoolSpend + // *ActionView_CommunityPoolOutput + // *ActionView_CommunityPoolDeposit // *ActionView_UndelegateClaim // *ActionView_Ics20Withdrawal ActionView isActionView_ActionView `protobuf_oneof:"action_view"` @@ -1249,7 +999,7 @@ func (m *ActionView) Reset() { *m = ActionView{} } func (m *ActionView) String() string { return proto.CompactTextString(m) } func (*ActionView) ProtoMessage() {} func (*ActionView) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{14} + return fileDescriptor_cd20ea79758052c4, []int{10} } func (m *ActionView) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1285,70 +1035,70 @@ type isActionView_ActionView interface { } type ActionView_Spend struct { - Spend *SpendView `protobuf:"bytes,1,opt,name=spend,proto3,oneof" json:"spend,omitempty"` + Spend *v1alpha14.SpendView `protobuf:"bytes,1,opt,name=spend,proto3,oneof" json:"spend,omitempty"` } type ActionView_Output struct { - Output *OutputView `protobuf:"bytes,2,opt,name=output,proto3,oneof" json:"output,omitempty"` + Output *v1alpha14.OutputView `protobuf:"bytes,2,opt,name=output,proto3,oneof" json:"output,omitempty"` } type ActionView_Swap struct { - Swap *v1alpha11.SwapView `protobuf:"bytes,3,opt,name=swap,proto3,oneof" json:"swap,omitempty"` + Swap *v1alpha15.SwapView `protobuf:"bytes,3,opt,name=swap,proto3,oneof" json:"swap,omitempty"` } type ActionView_SwapClaim struct { - SwapClaim *v1alpha11.SwapClaimView `protobuf:"bytes,4,opt,name=swap_claim,json=swapClaim,proto3,oneof" json:"swap_claim,omitempty"` + SwapClaim *v1alpha15.SwapClaimView `protobuf:"bytes,4,opt,name=swap_claim,json=swapClaim,proto3,oneof" json:"swap_claim,omitempty"` } type ActionView_ValidatorDefinition struct { - ValidatorDefinition *v1alpha12.ValidatorDefinition `protobuf:"bytes,16,opt,name=validator_definition,json=validatorDefinition,proto3,oneof" json:"validator_definition,omitempty"` + ValidatorDefinition *v1alpha16.ValidatorDefinition `protobuf:"bytes,16,opt,name=validator_definition,json=validatorDefinition,proto3,oneof" json:"validator_definition,omitempty"` } -type ActionView_IbcAction struct { - IbcAction *v1alpha13.IbcAction `protobuf:"bytes,17,opt,name=ibc_action,json=ibcAction,proto3,oneof" json:"ibc_action,omitempty"` +type ActionView_IbcRelayAction struct { + IbcRelayAction *v1alpha17.IbcRelay `protobuf:"bytes,17,opt,name=ibc_relay_action,json=ibcRelayAction,proto3,oneof" json:"ibc_relay_action,omitempty"` } type ActionView_ProposalSubmit struct { - ProposalSubmit *v1alpha14.ProposalSubmit `protobuf:"bytes,18,opt,name=proposal_submit,json=proposalSubmit,proto3,oneof" json:"proposal_submit,omitempty"` + ProposalSubmit *v1alpha18.ProposalSubmit `protobuf:"bytes,18,opt,name=proposal_submit,json=proposalSubmit,proto3,oneof" json:"proposal_submit,omitempty"` } type ActionView_ProposalWithdraw struct { - ProposalWithdraw *v1alpha14.ProposalWithdraw `protobuf:"bytes,19,opt,name=proposal_withdraw,json=proposalWithdraw,proto3,oneof" json:"proposal_withdraw,omitempty"` + ProposalWithdraw *v1alpha18.ProposalWithdraw `protobuf:"bytes,19,opt,name=proposal_withdraw,json=proposalWithdraw,proto3,oneof" json:"proposal_withdraw,omitempty"` } type ActionView_ValidatorVote struct { - ValidatorVote *v1alpha14.ValidatorVote `protobuf:"bytes,20,opt,name=validator_vote,json=validatorVote,proto3,oneof" json:"validator_vote,omitempty"` + ValidatorVote *v1alpha18.ValidatorVote `protobuf:"bytes,20,opt,name=validator_vote,json=validatorVote,proto3,oneof" json:"validator_vote,omitempty"` } type ActionView_DelegatorVote struct { - DelegatorVote *DelegatorVoteView `protobuf:"bytes,21,opt,name=delegator_vote,json=delegatorVote,proto3,oneof" json:"delegator_vote,omitempty"` + DelegatorVote *v1alpha18.DelegatorVoteView `protobuf:"bytes,21,opt,name=delegator_vote,json=delegatorVote,proto3,oneof" json:"delegator_vote,omitempty"` } type ActionView_ProposalDepositClaim struct { - ProposalDepositClaim *v1alpha14.ProposalDepositClaim `protobuf:"bytes,22,opt,name=proposal_deposit_claim,json=proposalDepositClaim,proto3,oneof" json:"proposal_deposit_claim,omitempty"` + ProposalDepositClaim *v1alpha18.ProposalDepositClaim `protobuf:"bytes,22,opt,name=proposal_deposit_claim,json=proposalDepositClaim,proto3,oneof" json:"proposal_deposit_claim,omitempty"` } type ActionView_PositionOpen struct { - PositionOpen *v1alpha11.PositionOpen `protobuf:"bytes,30,opt,name=position_open,json=positionOpen,proto3,oneof" json:"position_open,omitempty"` + PositionOpen *v1alpha15.PositionOpen `protobuf:"bytes,30,opt,name=position_open,json=positionOpen,proto3,oneof" json:"position_open,omitempty"` } type ActionView_PositionClose struct { - PositionClose *v1alpha11.PositionClose `protobuf:"bytes,31,opt,name=position_close,json=positionClose,proto3,oneof" json:"position_close,omitempty"` + PositionClose *v1alpha15.PositionClose `protobuf:"bytes,31,opt,name=position_close,json=positionClose,proto3,oneof" json:"position_close,omitempty"` } type ActionView_PositionWithdraw struct { - PositionWithdraw *v1alpha11.PositionWithdraw `protobuf:"bytes,32,opt,name=position_withdraw,json=positionWithdraw,proto3,oneof" json:"position_withdraw,omitempty"` + PositionWithdraw *v1alpha15.PositionWithdraw `protobuf:"bytes,32,opt,name=position_withdraw,json=positionWithdraw,proto3,oneof" json:"position_withdraw,omitempty"` } type ActionView_PositionRewardClaim struct { - PositionRewardClaim *v1alpha11.PositionRewardClaim `protobuf:"bytes,34,opt,name=position_reward_claim,json=positionRewardClaim,proto3,oneof" json:"position_reward_claim,omitempty"` + PositionRewardClaim *v1alpha15.PositionRewardClaim `protobuf:"bytes,34,opt,name=position_reward_claim,json=positionRewardClaim,proto3,oneof" json:"position_reward_claim,omitempty"` } type ActionView_Delegate struct { - Delegate *v1alpha12.Delegate `protobuf:"bytes,41,opt,name=delegate,proto3,oneof" json:"delegate,omitempty"` + Delegate *v1alpha16.Delegate `protobuf:"bytes,41,opt,name=delegate,proto3,oneof" json:"delegate,omitempty"` } type ActionView_Undelegate struct { - Undelegate *v1alpha12.Undelegate `protobuf:"bytes,42,opt,name=undelegate,proto3,oneof" json:"undelegate,omitempty"` + Undelegate *v1alpha16.Undelegate `protobuf:"bytes,42,opt,name=undelegate,proto3,oneof" json:"undelegate,omitempty"` } -type ActionView_DaoSpend struct { - DaoSpend *v1alpha14.DaoSpend `protobuf:"bytes,50,opt,name=dao_spend,json=daoSpend,proto3,oneof" json:"dao_spend,omitempty"` +type ActionView_CommunityPoolSpend struct { + CommunityPoolSpend *v1alpha18.CommunityPoolSpend `protobuf:"bytes,50,opt,name=community_pool_spend,json=communityPoolSpend,proto3,oneof" json:"community_pool_spend,omitempty"` } -type ActionView_DaoOutput struct { - DaoOutput *v1alpha14.DaoOutput `protobuf:"bytes,51,opt,name=dao_output,json=daoOutput,proto3,oneof" json:"dao_output,omitempty"` +type ActionView_CommunityPoolOutput struct { + CommunityPoolOutput *v1alpha18.CommunityPoolOutput `protobuf:"bytes,51,opt,name=community_pool_output,json=communityPoolOutput,proto3,oneof" json:"community_pool_output,omitempty"` } -type ActionView_DaoDeposit struct { - DaoDeposit *v1alpha14.DaoDeposit `protobuf:"bytes,52,opt,name=dao_deposit,json=daoDeposit,proto3,oneof" json:"dao_deposit,omitempty"` +type ActionView_CommunityPoolDeposit struct { + CommunityPoolDeposit *v1alpha18.CommunityPoolDeposit `protobuf:"bytes,52,opt,name=community_pool_deposit,json=communityPoolDeposit,proto3,oneof" json:"community_pool_deposit,omitempty"` } type ActionView_UndelegateClaim struct { - UndelegateClaim *v1alpha12.UndelegateClaim `protobuf:"bytes,43,opt,name=undelegate_claim,json=undelegateClaim,proto3,oneof" json:"undelegate_claim,omitempty"` + UndelegateClaim *v1alpha16.UndelegateClaim `protobuf:"bytes,43,opt,name=undelegate_claim,json=undelegateClaim,proto3,oneof" json:"undelegate_claim,omitempty"` } type ActionView_Ics20Withdrawal struct { - Ics20Withdrawal *v1alpha13.Ics20Withdrawal `protobuf:"bytes,200,opt,name=ics20_withdrawal,json=ics20Withdrawal,proto3,oneof" json:"ics20_withdrawal,omitempty"` + Ics20Withdrawal *v1alpha17.Ics20Withdrawal `protobuf:"bytes,200,opt,name=ics20_withdrawal,json=ics20Withdrawal,proto3,oneof" json:"ics20_withdrawal,omitempty"` } func (*ActionView_Spend) isActionView_ActionView() {} @@ -1356,7 +1106,7 @@ func (*ActionView_Output) isActionView_ActionView() {} func (*ActionView_Swap) isActionView_ActionView() {} func (*ActionView_SwapClaim) isActionView_ActionView() {} func (*ActionView_ValidatorDefinition) isActionView_ActionView() {} -func (*ActionView_IbcAction) isActionView_ActionView() {} +func (*ActionView_IbcRelayAction) isActionView_ActionView() {} func (*ActionView_ProposalSubmit) isActionView_ActionView() {} func (*ActionView_ProposalWithdraw) isActionView_ActionView() {} func (*ActionView_ValidatorVote) isActionView_ActionView() {} @@ -1368,9 +1118,9 @@ func (*ActionView_PositionWithdraw) isActionView_ActionView() {} func (*ActionView_PositionRewardClaim) isActionView_ActionView() {} func (*ActionView_Delegate) isActionView_ActionView() {} func (*ActionView_Undelegate) isActionView_ActionView() {} -func (*ActionView_DaoSpend) isActionView_ActionView() {} -func (*ActionView_DaoOutput) isActionView_ActionView() {} -func (*ActionView_DaoDeposit) isActionView_ActionView() {} +func (*ActionView_CommunityPoolSpend) isActionView_ActionView() {} +func (*ActionView_CommunityPoolOutput) isActionView_ActionView() {} +func (*ActionView_CommunityPoolDeposit) isActionView_ActionView() {} func (*ActionView_UndelegateClaim) isActionView_ActionView() {} func (*ActionView_Ics20Withdrawal) isActionView_ActionView() {} @@ -1381,154 +1131,154 @@ func (m *ActionView) GetActionView() isActionView_ActionView { return nil } -func (m *ActionView) GetSpend() *SpendView { +func (m *ActionView) GetSpend() *v1alpha14.SpendView { if x, ok := m.GetActionView().(*ActionView_Spend); ok { return x.Spend } return nil } -func (m *ActionView) GetOutput() *OutputView { +func (m *ActionView) GetOutput() *v1alpha14.OutputView { if x, ok := m.GetActionView().(*ActionView_Output); ok { return x.Output } return nil } -func (m *ActionView) GetSwap() *v1alpha11.SwapView { +func (m *ActionView) GetSwap() *v1alpha15.SwapView { if x, ok := m.GetActionView().(*ActionView_Swap); ok { return x.Swap } return nil } -func (m *ActionView) GetSwapClaim() *v1alpha11.SwapClaimView { +func (m *ActionView) GetSwapClaim() *v1alpha15.SwapClaimView { if x, ok := m.GetActionView().(*ActionView_SwapClaim); ok { return x.SwapClaim } return nil } -func (m *ActionView) GetValidatorDefinition() *v1alpha12.ValidatorDefinition { +func (m *ActionView) GetValidatorDefinition() *v1alpha16.ValidatorDefinition { if x, ok := m.GetActionView().(*ActionView_ValidatorDefinition); ok { return x.ValidatorDefinition } return nil } -func (m *ActionView) GetIbcAction() *v1alpha13.IbcAction { - if x, ok := m.GetActionView().(*ActionView_IbcAction); ok { - return x.IbcAction +func (m *ActionView) GetIbcRelayAction() *v1alpha17.IbcRelay { + if x, ok := m.GetActionView().(*ActionView_IbcRelayAction); ok { + return x.IbcRelayAction } return nil } -func (m *ActionView) GetProposalSubmit() *v1alpha14.ProposalSubmit { +func (m *ActionView) GetProposalSubmit() *v1alpha18.ProposalSubmit { if x, ok := m.GetActionView().(*ActionView_ProposalSubmit); ok { return x.ProposalSubmit } return nil } -func (m *ActionView) GetProposalWithdraw() *v1alpha14.ProposalWithdraw { +func (m *ActionView) GetProposalWithdraw() *v1alpha18.ProposalWithdraw { if x, ok := m.GetActionView().(*ActionView_ProposalWithdraw); ok { return x.ProposalWithdraw } return nil } -func (m *ActionView) GetValidatorVote() *v1alpha14.ValidatorVote { +func (m *ActionView) GetValidatorVote() *v1alpha18.ValidatorVote { if x, ok := m.GetActionView().(*ActionView_ValidatorVote); ok { return x.ValidatorVote } return nil } -func (m *ActionView) GetDelegatorVote() *DelegatorVoteView { +func (m *ActionView) GetDelegatorVote() *v1alpha18.DelegatorVoteView { if x, ok := m.GetActionView().(*ActionView_DelegatorVote); ok { return x.DelegatorVote } return nil } -func (m *ActionView) GetProposalDepositClaim() *v1alpha14.ProposalDepositClaim { +func (m *ActionView) GetProposalDepositClaim() *v1alpha18.ProposalDepositClaim { if x, ok := m.GetActionView().(*ActionView_ProposalDepositClaim); ok { return x.ProposalDepositClaim } return nil } -func (m *ActionView) GetPositionOpen() *v1alpha11.PositionOpen { +func (m *ActionView) GetPositionOpen() *v1alpha15.PositionOpen { if x, ok := m.GetActionView().(*ActionView_PositionOpen); ok { return x.PositionOpen } return nil } -func (m *ActionView) GetPositionClose() *v1alpha11.PositionClose { +func (m *ActionView) GetPositionClose() *v1alpha15.PositionClose { if x, ok := m.GetActionView().(*ActionView_PositionClose); ok { return x.PositionClose } return nil } -func (m *ActionView) GetPositionWithdraw() *v1alpha11.PositionWithdraw { +func (m *ActionView) GetPositionWithdraw() *v1alpha15.PositionWithdraw { if x, ok := m.GetActionView().(*ActionView_PositionWithdraw); ok { return x.PositionWithdraw } return nil } -func (m *ActionView) GetPositionRewardClaim() *v1alpha11.PositionRewardClaim { +func (m *ActionView) GetPositionRewardClaim() *v1alpha15.PositionRewardClaim { if x, ok := m.GetActionView().(*ActionView_PositionRewardClaim); ok { return x.PositionRewardClaim } return nil } -func (m *ActionView) GetDelegate() *v1alpha12.Delegate { +func (m *ActionView) GetDelegate() *v1alpha16.Delegate { if x, ok := m.GetActionView().(*ActionView_Delegate); ok { return x.Delegate } return nil } -func (m *ActionView) GetUndelegate() *v1alpha12.Undelegate { +func (m *ActionView) GetUndelegate() *v1alpha16.Undelegate { if x, ok := m.GetActionView().(*ActionView_Undelegate); ok { return x.Undelegate } return nil } -func (m *ActionView) GetDaoSpend() *v1alpha14.DaoSpend { - if x, ok := m.GetActionView().(*ActionView_DaoSpend); ok { - return x.DaoSpend +func (m *ActionView) GetCommunityPoolSpend() *v1alpha18.CommunityPoolSpend { + if x, ok := m.GetActionView().(*ActionView_CommunityPoolSpend); ok { + return x.CommunityPoolSpend } return nil } -func (m *ActionView) GetDaoOutput() *v1alpha14.DaoOutput { - if x, ok := m.GetActionView().(*ActionView_DaoOutput); ok { - return x.DaoOutput +func (m *ActionView) GetCommunityPoolOutput() *v1alpha18.CommunityPoolOutput { + if x, ok := m.GetActionView().(*ActionView_CommunityPoolOutput); ok { + return x.CommunityPoolOutput } return nil } -func (m *ActionView) GetDaoDeposit() *v1alpha14.DaoDeposit { - if x, ok := m.GetActionView().(*ActionView_DaoDeposit); ok { - return x.DaoDeposit +func (m *ActionView) GetCommunityPoolDeposit() *v1alpha18.CommunityPoolDeposit { + if x, ok := m.GetActionView().(*ActionView_CommunityPoolDeposit); ok { + return x.CommunityPoolDeposit } return nil } -func (m *ActionView) GetUndelegateClaim() *v1alpha12.UndelegateClaim { +func (m *ActionView) GetUndelegateClaim() *v1alpha16.UndelegateClaim { if x, ok := m.GetActionView().(*ActionView_UndelegateClaim); ok { return x.UndelegateClaim } return nil } -func (m *ActionView) GetIcs20Withdrawal() *v1alpha13.Ics20Withdrawal { +func (m *ActionView) GetIcs20Withdrawal() *v1alpha17.Ics20Withdrawal { if x, ok := m.GetActionView().(*ActionView_Ics20Withdrawal); ok { return x.Ics20Withdrawal } @@ -1543,7 +1293,7 @@ func (*ActionView) XXX_OneofWrappers() []interface{} { (*ActionView_Swap)(nil), (*ActionView_SwapClaim)(nil), (*ActionView_ValidatorDefinition)(nil), - (*ActionView_IbcAction)(nil), + (*ActionView_IbcRelayAction)(nil), (*ActionView_ProposalSubmit)(nil), (*ActionView_ProposalWithdraw)(nil), (*ActionView_ValidatorVote)(nil), @@ -1555,34 +1305,38 @@ func (*ActionView) XXX_OneofWrappers() []interface{} { (*ActionView_PositionRewardClaim)(nil), (*ActionView_Delegate)(nil), (*ActionView_Undelegate)(nil), - (*ActionView_DaoSpend)(nil), - (*ActionView_DaoOutput)(nil), - (*ActionView_DaoDeposit)(nil), + (*ActionView_CommunityPoolSpend)(nil), + (*ActionView_CommunityPoolOutput)(nil), + (*ActionView_CommunityPoolDeposit)(nil), (*ActionView_UndelegateClaim)(nil), (*ActionView_Ics20Withdrawal)(nil), } } -type SpendView struct { - // Types that are valid to be assigned to SpendView: - // - // *SpendView_Visible_ - // *SpendView_Opaque_ - SpendView isSpendView_SpendView `protobuf_oneof:"spend_view"` +// The data required to authorize a transaction plan. +type AuthorizationData struct { + // The computed auth hash for the approved transaction plan. + EffectHash *v1alpha111.EffectHash `protobuf:"bytes,1,opt,name=effect_hash,json=effectHash,proto3" json:"effect_hash,omitempty"` + // The required spend authorizations, returned in the same order as the + // Spend actions in the original request. + SpendAuths []*v1alpha1.SpendAuthSignature `protobuf:"bytes,2,rep,name=spend_auths,json=spendAuths,proto3" json:"spend_auths,omitempty"` + // The required delegator vote authorizations, returned in the same order as the + // DelegatorVote actions in the original request. + DelegatorVoteAuths []*v1alpha1.SpendAuthSignature `protobuf:"bytes,3,rep,name=delegator_vote_auths,json=delegatorVoteAuths,proto3" json:"delegator_vote_auths,omitempty"` } -func (m *SpendView) Reset() { *m = SpendView{} } -func (m *SpendView) String() string { return proto.CompactTextString(m) } -func (*SpendView) ProtoMessage() {} -func (*SpendView) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{15} +func (m *AuthorizationData) Reset() { *m = AuthorizationData{} } +func (m *AuthorizationData) String() string { return proto.CompactTextString(m) } +func (*AuthorizationData) ProtoMessage() {} +func (*AuthorizationData) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{11} } -func (m *SpendView) XXX_Unmarshal(b []byte) error { +func (m *AuthorizationData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SpendView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *AuthorizationData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SpendView.Marshal(b, m, deterministic) + return xxx_messageInfo_AuthorizationData.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1592,80 +1346,60 @@ func (m *SpendView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *SpendView) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpendView.Merge(m, src) +func (m *AuthorizationData) XXX_Merge(src proto.Message) { + xxx_messageInfo_AuthorizationData.Merge(m, src) } -func (m *SpendView) XXX_Size() int { +func (m *AuthorizationData) XXX_Size() int { return m.Size() } -func (m *SpendView) XXX_DiscardUnknown() { - xxx_messageInfo_SpendView.DiscardUnknown(m) -} - -var xxx_messageInfo_SpendView proto.InternalMessageInfo - -type isSpendView_SpendView interface { - isSpendView_SpendView() - MarshalTo([]byte) (int, error) - Size() int -} - -type SpendView_Visible_ struct { - Visible *SpendView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` -} -type SpendView_Opaque_ struct { - Opaque *SpendView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +func (m *AuthorizationData) XXX_DiscardUnknown() { + xxx_messageInfo_AuthorizationData.DiscardUnknown(m) } -func (*SpendView_Visible_) isSpendView_SpendView() {} -func (*SpendView_Opaque_) isSpendView_SpendView() {} +var xxx_messageInfo_AuthorizationData proto.InternalMessageInfo -func (m *SpendView) GetSpendView() isSpendView_SpendView { +func (m *AuthorizationData) GetEffectHash() *v1alpha111.EffectHash { if m != nil { - return m.SpendView + return m.EffectHash } return nil } -func (m *SpendView) GetVisible() *SpendView_Visible { - if x, ok := m.GetSpendView().(*SpendView_Visible_); ok { - return x.Visible +func (m *AuthorizationData) GetSpendAuths() []*v1alpha1.SpendAuthSignature { + if m != nil { + return m.SpendAuths } return nil } -func (m *SpendView) GetOpaque() *SpendView_Opaque { - if x, ok := m.GetSpendView().(*SpendView_Opaque_); ok { - return x.Opaque +func (m *AuthorizationData) GetDelegatorVoteAuths() []*v1alpha1.SpendAuthSignature { + if m != nil { + return m.DelegatorVoteAuths } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*SpendView) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*SpendView_Visible_)(nil), - (*SpendView_Opaque_)(nil), - } -} - -type SpendView_Visible struct { - Spend *Spend `protobuf:"bytes,1,opt,name=spend,proto3" json:"spend,omitempty"` - Note *v1alpha1.NoteView `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` +// The data required for proving when building a transaction from a plan. +type WitnessData struct { + // The anchor for the state transition proofs. + Anchor *v1alpha11.MerkleRoot `protobuf:"bytes,1,opt,name=anchor,proto3" json:"anchor,omitempty"` + // The auth paths for the notes the transaction spends, in the + // same order as the spends in the transaction plan. + StateCommitmentProofs []*v1alpha11.StateCommitmentProof `protobuf:"bytes,2,rep,name=state_commitment_proofs,json=stateCommitmentProofs,proto3" json:"state_commitment_proofs,omitempty"` } -func (m *SpendView_Visible) Reset() { *m = SpendView_Visible{} } -func (m *SpendView_Visible) String() string { return proto.CompactTextString(m) } -func (*SpendView_Visible) ProtoMessage() {} -func (*SpendView_Visible) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{15, 0} -} -func (m *SpendView_Visible) XXX_Unmarshal(b []byte) error { +func (m *WitnessData) Reset() { *m = WitnessData{} } +func (m *WitnessData) String() string { return proto.CompactTextString(m) } +func (*WitnessData) ProtoMessage() {} +func (*WitnessData) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{12} +} +func (m *WitnessData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SpendView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *WitnessData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SpendView_Visible.Marshal(b, m, deterministic) + return xxx_messageInfo_WitnessData.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1675,48 +1409,60 @@ func (m *SpendView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } -func (m *SpendView_Visible) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpendView_Visible.Merge(m, src) +func (m *WitnessData) XXX_Merge(src proto.Message) { + xxx_messageInfo_WitnessData.Merge(m, src) } -func (m *SpendView_Visible) XXX_Size() int { +func (m *WitnessData) XXX_Size() int { return m.Size() } -func (m *SpendView_Visible) XXX_DiscardUnknown() { - xxx_messageInfo_SpendView_Visible.DiscardUnknown(m) +func (m *WitnessData) XXX_DiscardUnknown() { + xxx_messageInfo_WitnessData.DiscardUnknown(m) } -var xxx_messageInfo_SpendView_Visible proto.InternalMessageInfo +var xxx_messageInfo_WitnessData proto.InternalMessageInfo -func (m *SpendView_Visible) GetSpend() *Spend { +func (m *WitnessData) GetAnchor() *v1alpha11.MerkleRoot { if m != nil { - return m.Spend + return m.Anchor } return nil } -func (m *SpendView_Visible) GetNote() *v1alpha1.NoteView { +func (m *WitnessData) GetStateCommitmentProofs() []*v1alpha11.StateCommitmentProof { if m != nil { - return m.Note + return m.StateCommitmentProofs } return nil } -type SpendView_Opaque struct { - Spend *Spend `protobuf:"bytes,1,opt,name=spend,proto3" json:"spend,omitempty"` +// Describes a planned transaction. Permits clients to prepare a transaction +// prior submission, so that a user can review it prior to authorizing its execution. +// +// The `TransactionPlan` is a fully determined bundle binding all of a transaction's effects. +// The only thing it does not include is the witness data used for proving. +type TransactionPlan struct { + // The sequence of actions planned for this transaction. + Actions []*ActionPlan `protobuf:"bytes,1,rep,name=actions,proto3" json:"actions,omitempty"` + // Parameters determining if a transaction should be accepted by this chain. + TransactionParameters *TransactionParameters `protobuf:"bytes,2,opt,name=transaction_parameters,json=transactionParameters,proto3" json:"transaction_parameters,omitempty"` + // Detection data for use with Fuzzy Message Detection + DetectionData *DetectionDataPlan `protobuf:"bytes,4,opt,name=detection_data,json=detectionData,proto3" json:"detection_data,omitempty"` + // The memo plan for this transaction. + Memo *MemoPlan `protobuf:"bytes,5,opt,name=memo,proto3" json:"memo,omitempty"` } -func (m *SpendView_Opaque) Reset() { *m = SpendView_Opaque{} } -func (m *SpendView_Opaque) String() string { return proto.CompactTextString(m) } -func (*SpendView_Opaque) ProtoMessage() {} -func (*SpendView_Opaque) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{15, 1} +func (m *TransactionPlan) Reset() { *m = TransactionPlan{} } +func (m *TransactionPlan) String() string { return proto.CompactTextString(m) } +func (*TransactionPlan) ProtoMessage() {} +func (*TransactionPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{13} } -func (m *SpendView_Opaque) XXX_Unmarshal(b []byte) error { +func (m *TransactionPlan) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SpendView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *TransactionPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SpendView_Opaque.Marshal(b, m, deterministic) + return xxx_messageInfo_TransactionPlan.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1726,128 +1472,62 @@ func (m *SpendView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } -func (m *SpendView_Opaque) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpendView_Opaque.Merge(m, src) +func (m *TransactionPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionPlan.Merge(m, src) } -func (m *SpendView_Opaque) XXX_Size() int { +func (m *TransactionPlan) XXX_Size() int { return m.Size() } -func (m *SpendView_Opaque) XXX_DiscardUnknown() { - xxx_messageInfo_SpendView_Opaque.DiscardUnknown(m) +func (m *TransactionPlan) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionPlan.DiscardUnknown(m) } -var xxx_messageInfo_SpendView_Opaque proto.InternalMessageInfo +var xxx_messageInfo_TransactionPlan proto.InternalMessageInfo -func (m *SpendView_Opaque) GetSpend() *Spend { +func (m *TransactionPlan) GetActions() []*ActionPlan { if m != nil { - return m.Spend + return m.Actions } return nil } -type DelegatorVoteView struct { - // Types that are valid to be assigned to DelegatorVote: - // - // *DelegatorVoteView_Visible_ - // *DelegatorVoteView_Opaque_ - DelegatorVote isDelegatorVoteView_DelegatorVote `protobuf_oneof:"delegator_vote"` -} - -func (m *DelegatorVoteView) Reset() { *m = DelegatorVoteView{} } -func (m *DelegatorVoteView) String() string { return proto.CompactTextString(m) } -func (*DelegatorVoteView) ProtoMessage() {} -func (*DelegatorVoteView) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{16} -} -func (m *DelegatorVoteView) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DelegatorVoteView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DelegatorVoteView.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 *DelegatorVoteView) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelegatorVoteView.Merge(m, src) -} -func (m *DelegatorVoteView) XXX_Size() int { - return m.Size() -} -func (m *DelegatorVoteView) XXX_DiscardUnknown() { - xxx_messageInfo_DelegatorVoteView.DiscardUnknown(m) -} - -var xxx_messageInfo_DelegatorVoteView proto.InternalMessageInfo - -type isDelegatorVoteView_DelegatorVote interface { - isDelegatorVoteView_DelegatorVote() - MarshalTo([]byte) (int, error) - Size() int -} - -type DelegatorVoteView_Visible_ struct { - Visible *DelegatorVoteView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` -} -type DelegatorVoteView_Opaque_ struct { - Opaque *DelegatorVoteView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` -} - -func (*DelegatorVoteView_Visible_) isDelegatorVoteView_DelegatorVote() {} -func (*DelegatorVoteView_Opaque_) isDelegatorVoteView_DelegatorVote() {} - -func (m *DelegatorVoteView) GetDelegatorVote() isDelegatorVoteView_DelegatorVote { +func (m *TransactionPlan) GetTransactionParameters() *TransactionParameters { if m != nil { - return m.DelegatorVote + return m.TransactionParameters } return nil } -func (m *DelegatorVoteView) GetVisible() *DelegatorVoteView_Visible { - if x, ok := m.GetDelegatorVote().(*DelegatorVoteView_Visible_); ok { - return x.Visible +func (m *TransactionPlan) GetDetectionData() *DetectionDataPlan { + if m != nil { + return m.DetectionData } return nil } -func (m *DelegatorVoteView) GetOpaque() *DelegatorVoteView_Opaque { - if x, ok := m.GetDelegatorVote().(*DelegatorVoteView_Opaque_); ok { - return x.Opaque +func (m *TransactionPlan) GetMemo() *MemoPlan { + if m != nil { + return m.Memo } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*DelegatorVoteView) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*DelegatorVoteView_Visible_)(nil), - (*DelegatorVoteView_Opaque_)(nil), - } -} - -type DelegatorVoteView_Visible struct { - DelegatorVote *v1alpha14.DelegatorVote `protobuf:"bytes,1,opt,name=delegator_vote,json=delegatorVote,proto3" json:"delegator_vote,omitempty"` - Note *v1alpha1.NoteView `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` +type DetectionDataPlan struct { + CluePlans []*CluePlan `protobuf:"bytes,5,rep,name=clue_plans,json=cluePlans,proto3" json:"clue_plans,omitempty"` } -func (m *DelegatorVoteView_Visible) Reset() { *m = DelegatorVoteView_Visible{} } -func (m *DelegatorVoteView_Visible) String() string { return proto.CompactTextString(m) } -func (*DelegatorVoteView_Visible) ProtoMessage() {} -func (*DelegatorVoteView_Visible) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{16, 0} +func (m *DetectionDataPlan) Reset() { *m = DetectionDataPlan{} } +func (m *DetectionDataPlan) String() string { return proto.CompactTextString(m) } +func (*DetectionDataPlan) ProtoMessage() {} +func (*DetectionDataPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{14} } -func (m *DelegatorVoteView_Visible) XXX_Unmarshal(b []byte) error { +func (m *DetectionDataPlan) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *DelegatorVoteView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *DetectionDataPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_DelegatorVoteView_Visible.Marshal(b, m, deterministic) + return xxx_messageInfo_DetectionDataPlan.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1857,48 +1537,69 @@ func (m *DelegatorVoteView_Visible) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } -func (m *DelegatorVoteView_Visible) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelegatorVoteView_Visible.Merge(m, src) +func (m *DetectionDataPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_DetectionDataPlan.Merge(m, src) } -func (m *DelegatorVoteView_Visible) XXX_Size() int { +func (m *DetectionDataPlan) XXX_Size() int { return m.Size() } -func (m *DelegatorVoteView_Visible) XXX_DiscardUnknown() { - xxx_messageInfo_DelegatorVoteView_Visible.DiscardUnknown(m) +func (m *DetectionDataPlan) XXX_DiscardUnknown() { + xxx_messageInfo_DetectionDataPlan.DiscardUnknown(m) } -var xxx_messageInfo_DelegatorVoteView_Visible proto.InternalMessageInfo - -func (m *DelegatorVoteView_Visible) GetDelegatorVote() *v1alpha14.DelegatorVote { - if m != nil { - return m.DelegatorVote - } - return nil -} +var xxx_messageInfo_DetectionDataPlan proto.InternalMessageInfo -func (m *DelegatorVoteView_Visible) GetNote() *v1alpha1.NoteView { +func (m *DetectionDataPlan) GetCluePlans() []*CluePlan { if m != nil { - return m.Note + return m.CluePlans } return nil } -type DelegatorVoteView_Opaque struct { - DelegatorVote *v1alpha14.DelegatorVote `protobuf:"bytes,1,opt,name=delegator_vote,json=delegatorVote,proto3" json:"delegator_vote,omitempty"` +// Describes a planned transaction action. +// +// Some transaction Actions don't have any private data and are treated as being plans +// themselves. +type ActionPlan struct { + // Types that are valid to be assigned to Action: + // + // *ActionPlan_Spend + // *ActionPlan_Output + // *ActionPlan_Swap + // *ActionPlan_SwapClaim + // *ActionPlan_ValidatorDefinition + // *ActionPlan_IbcRelayAction + // *ActionPlan_ProposalSubmit + // *ActionPlan_ProposalWithdraw + // *ActionPlan_ValidatorVote + // *ActionPlan_DelegatorVote + // *ActionPlan_ProposalDepositClaim + // *ActionPlan_Withdrawal + // *ActionPlan_PositionOpen + // *ActionPlan_PositionClose + // *ActionPlan_PositionWithdraw + // *ActionPlan_PositionRewardClaim + // *ActionPlan_Delegate + // *ActionPlan_Undelegate + // *ActionPlan_UndelegateClaim + // *ActionPlan_CommunityPoolSpend + // *ActionPlan_CommunityPoolOutput + // *ActionPlan_CommunityPoolDeposit + Action isActionPlan_Action `protobuf_oneof:"action"` } -func (m *DelegatorVoteView_Opaque) Reset() { *m = DelegatorVoteView_Opaque{} } -func (m *DelegatorVoteView_Opaque) String() string { return proto.CompactTextString(m) } -func (*DelegatorVoteView_Opaque) ProtoMessage() {} -func (*DelegatorVoteView_Opaque) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{16, 1} +func (m *ActionPlan) Reset() { *m = ActionPlan{} } +func (m *ActionPlan) String() string { return proto.CompactTextString(m) } +func (*ActionPlan) ProtoMessage() {} +func (*ActionPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{15} } -func (m *DelegatorVoteView_Opaque) XXX_Unmarshal(b []byte) error { +func (m *ActionPlan) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *DelegatorVoteView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ActionPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_DelegatorVoteView_Opaque.Marshal(b, m, deterministic) + return xxx_messageInfo_ActionPlan.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1908,303 +1609,325 @@ func (m *DelegatorVoteView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } -func (m *DelegatorVoteView_Opaque) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelegatorVoteView_Opaque.Merge(m, src) +func (m *ActionPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_ActionPlan.Merge(m, src) } -func (m *DelegatorVoteView_Opaque) XXX_Size() int { +func (m *ActionPlan) XXX_Size() int { return m.Size() } -func (m *DelegatorVoteView_Opaque) XXX_DiscardUnknown() { - xxx_messageInfo_DelegatorVoteView_Opaque.DiscardUnknown(m) +func (m *ActionPlan) XXX_DiscardUnknown() { + xxx_messageInfo_ActionPlan.DiscardUnknown(m) } -var xxx_messageInfo_DelegatorVoteView_Opaque proto.InternalMessageInfo +var xxx_messageInfo_ActionPlan proto.InternalMessageInfo -func (m *DelegatorVoteView_Opaque) GetDelegatorVote() *v1alpha14.DelegatorVote { - if m != nil { - return m.DelegatorVote - } - return nil +type isActionPlan_Action interface { + isActionPlan_Action() + MarshalTo([]byte) (int, error) + Size() int } -type OutputView struct { - // Types that are valid to be assigned to OutputView: - // - // *OutputView_Visible_ - // *OutputView_Opaque_ - OutputView isOutputView_OutputView `protobuf_oneof:"output_view"` +type ActionPlan_Spend struct { + Spend *v1alpha14.SpendPlan `protobuf:"bytes,1,opt,name=spend,proto3,oneof" json:"spend,omitempty"` } - -func (m *OutputView) Reset() { *m = OutputView{} } -func (m *OutputView) String() string { return proto.CompactTextString(m) } -func (*OutputView) ProtoMessage() {} -func (*OutputView) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{17} +type ActionPlan_Output struct { + Output *v1alpha14.OutputPlan `protobuf:"bytes,2,opt,name=output,proto3,oneof" json:"output,omitempty"` } -func (m *OutputView) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) +type ActionPlan_Swap struct { + Swap *v1alpha15.SwapPlan `protobuf:"bytes,3,opt,name=swap,proto3,oneof" json:"swap,omitempty"` } -func (m *OutputView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_OutputView.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } +type ActionPlan_SwapClaim struct { + SwapClaim *v1alpha15.SwapClaimPlan `protobuf:"bytes,4,opt,name=swap_claim,json=swapClaim,proto3,oneof" json:"swap_claim,omitempty"` } -func (m *OutputView) XXX_Merge(src proto.Message) { - xxx_messageInfo_OutputView.Merge(m, src) +type ActionPlan_ValidatorDefinition struct { + ValidatorDefinition *v1alpha16.ValidatorDefinition `protobuf:"bytes,16,opt,name=validator_definition,json=validatorDefinition,proto3,oneof" json:"validator_definition,omitempty"` } -func (m *OutputView) XXX_Size() int { - return m.Size() +type ActionPlan_IbcRelayAction struct { + IbcRelayAction *v1alpha17.IbcRelay `protobuf:"bytes,17,opt,name=ibc_relay_action,json=ibcRelayAction,proto3,oneof" json:"ibc_relay_action,omitempty"` } -func (m *OutputView) XXX_DiscardUnknown() { - xxx_messageInfo_OutputView.DiscardUnknown(m) +type ActionPlan_ProposalSubmit struct { + ProposalSubmit *v1alpha18.ProposalSubmit `protobuf:"bytes,18,opt,name=proposal_submit,json=proposalSubmit,proto3,oneof" json:"proposal_submit,omitempty"` } - -var xxx_messageInfo_OutputView proto.InternalMessageInfo - -type isOutputView_OutputView interface { - isOutputView_OutputView() - MarshalTo([]byte) (int, error) - Size() int +type ActionPlan_ProposalWithdraw struct { + ProposalWithdraw *v1alpha18.ProposalWithdraw `protobuf:"bytes,19,opt,name=proposal_withdraw,json=proposalWithdraw,proto3,oneof" json:"proposal_withdraw,omitempty"` } - -type OutputView_Visible_ struct { - Visible *OutputView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` +type ActionPlan_ValidatorVote struct { + ValidatorVote *v1alpha18.ValidatorVote `protobuf:"bytes,20,opt,name=validator_vote,json=validatorVote,proto3,oneof" json:"validator_vote,omitempty"` +} +type ActionPlan_DelegatorVote struct { + DelegatorVote *v1alpha18.DelegatorVotePlan `protobuf:"bytes,21,opt,name=delegator_vote,json=delegatorVote,proto3,oneof" json:"delegator_vote,omitempty"` +} +type ActionPlan_ProposalDepositClaim struct { + ProposalDepositClaim *v1alpha18.ProposalDepositClaim `protobuf:"bytes,22,opt,name=proposal_deposit_claim,json=proposalDepositClaim,proto3,oneof" json:"proposal_deposit_claim,omitempty"` +} +type ActionPlan_Withdrawal struct { + Withdrawal *v1alpha17.Ics20Withdrawal `protobuf:"bytes,23,opt,name=withdrawal,proto3,oneof" json:"withdrawal,omitempty"` +} +type ActionPlan_PositionOpen struct { + PositionOpen *v1alpha15.PositionOpen `protobuf:"bytes,30,opt,name=position_open,json=positionOpen,proto3,oneof" json:"position_open,omitempty"` +} +type ActionPlan_PositionClose struct { + PositionClose *v1alpha15.PositionClose `protobuf:"bytes,31,opt,name=position_close,json=positionClose,proto3,oneof" json:"position_close,omitempty"` } -type OutputView_Opaque_ struct { - Opaque *OutputView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +type ActionPlan_PositionWithdraw struct { + PositionWithdraw *v1alpha15.PositionWithdrawPlan `protobuf:"bytes,32,opt,name=position_withdraw,json=positionWithdraw,proto3,oneof" json:"position_withdraw,omitempty"` +} +type ActionPlan_PositionRewardClaim struct { + PositionRewardClaim *v1alpha15.PositionRewardClaimPlan `protobuf:"bytes,34,opt,name=position_reward_claim,json=positionRewardClaim,proto3,oneof" json:"position_reward_claim,omitempty"` +} +type ActionPlan_Delegate struct { + Delegate *v1alpha16.Delegate `protobuf:"bytes,40,opt,name=delegate,proto3,oneof" json:"delegate,omitempty"` +} +type ActionPlan_Undelegate struct { + Undelegate *v1alpha16.Undelegate `protobuf:"bytes,41,opt,name=undelegate,proto3,oneof" json:"undelegate,omitempty"` +} +type ActionPlan_UndelegateClaim struct { + UndelegateClaim *v1alpha16.UndelegateClaimPlan `protobuf:"bytes,42,opt,name=undelegate_claim,json=undelegateClaim,proto3,oneof" json:"undelegate_claim,omitempty"` +} +type ActionPlan_CommunityPoolSpend struct { + CommunityPoolSpend *v1alpha18.CommunityPoolSpend `protobuf:"bytes,50,opt,name=community_pool_spend,json=communityPoolSpend,proto3,oneof" json:"community_pool_spend,omitempty"` +} +type ActionPlan_CommunityPoolOutput struct { + CommunityPoolOutput *v1alpha18.CommunityPoolOutput `protobuf:"bytes,51,opt,name=community_pool_output,json=communityPoolOutput,proto3,oneof" json:"community_pool_output,omitempty"` +} +type ActionPlan_CommunityPoolDeposit struct { + CommunityPoolDeposit *v1alpha18.CommunityPoolDeposit `protobuf:"bytes,52,opt,name=community_pool_deposit,json=communityPoolDeposit,proto3,oneof" json:"community_pool_deposit,omitempty"` } -func (*OutputView_Visible_) isOutputView_OutputView() {} -func (*OutputView_Opaque_) isOutputView_OutputView() {} +func (*ActionPlan_Spend) isActionPlan_Action() {} +func (*ActionPlan_Output) isActionPlan_Action() {} +func (*ActionPlan_Swap) isActionPlan_Action() {} +func (*ActionPlan_SwapClaim) isActionPlan_Action() {} +func (*ActionPlan_ValidatorDefinition) isActionPlan_Action() {} +func (*ActionPlan_IbcRelayAction) isActionPlan_Action() {} +func (*ActionPlan_ProposalSubmit) isActionPlan_Action() {} +func (*ActionPlan_ProposalWithdraw) isActionPlan_Action() {} +func (*ActionPlan_ValidatorVote) isActionPlan_Action() {} +func (*ActionPlan_DelegatorVote) isActionPlan_Action() {} +func (*ActionPlan_ProposalDepositClaim) isActionPlan_Action() {} +func (*ActionPlan_Withdrawal) isActionPlan_Action() {} +func (*ActionPlan_PositionOpen) isActionPlan_Action() {} +func (*ActionPlan_PositionClose) isActionPlan_Action() {} +func (*ActionPlan_PositionWithdraw) isActionPlan_Action() {} +func (*ActionPlan_PositionRewardClaim) isActionPlan_Action() {} +func (*ActionPlan_Delegate) isActionPlan_Action() {} +func (*ActionPlan_Undelegate) isActionPlan_Action() {} +func (*ActionPlan_UndelegateClaim) isActionPlan_Action() {} +func (*ActionPlan_CommunityPoolSpend) isActionPlan_Action() {} +func (*ActionPlan_CommunityPoolOutput) isActionPlan_Action() {} +func (*ActionPlan_CommunityPoolDeposit) isActionPlan_Action() {} -func (m *OutputView) GetOutputView() isOutputView_OutputView { +func (m *ActionPlan) GetAction() isActionPlan_Action { if m != nil { - return m.OutputView + return m.Action } return nil } -func (m *OutputView) GetVisible() *OutputView_Visible { - if x, ok := m.GetOutputView().(*OutputView_Visible_); ok { - return x.Visible +func (m *ActionPlan) GetSpend() *v1alpha14.SpendPlan { + if x, ok := m.GetAction().(*ActionPlan_Spend); ok { + return x.Spend } return nil } -func (m *OutputView) GetOpaque() *OutputView_Opaque { - if x, ok := m.GetOutputView().(*OutputView_Opaque_); ok { - return x.Opaque +func (m *ActionPlan) GetOutput() *v1alpha14.OutputPlan { + if x, ok := m.GetAction().(*ActionPlan_Output); ok { + return x.Output } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*OutputView) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*OutputView_Visible_)(nil), - (*OutputView_Opaque_)(nil), +func (m *ActionPlan) GetSwap() *v1alpha15.SwapPlan { + if x, ok := m.GetAction().(*ActionPlan_Swap); ok { + return x.Swap } + return nil } -type OutputView_Visible struct { - Output *Output `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"` - Note *v1alpha1.NoteView `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` - PayloadKey *PayloadKey `protobuf:"bytes,3,opt,name=payload_key,json=payloadKey,proto3" json:"payload_key,omitempty"` +func (m *ActionPlan) GetSwapClaim() *v1alpha15.SwapClaimPlan { + if x, ok := m.GetAction().(*ActionPlan_SwapClaim); ok { + return x.SwapClaim + } + return nil } -func (m *OutputView_Visible) Reset() { *m = OutputView_Visible{} } -func (m *OutputView_Visible) String() string { return proto.CompactTextString(m) } -func (*OutputView_Visible) ProtoMessage() {} -func (*OutputView_Visible) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{17, 0} -} -func (m *OutputView_Visible) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *OutputView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_OutputView_Visible.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 *ActionPlan) GetValidatorDefinition() *v1alpha16.ValidatorDefinition { + if x, ok := m.GetAction().(*ActionPlan_ValidatorDefinition); ok { + return x.ValidatorDefinition } + return nil } -func (m *OutputView_Visible) XXX_Merge(src proto.Message) { - xxx_messageInfo_OutputView_Visible.Merge(m, src) -} -func (m *OutputView_Visible) XXX_Size() int { - return m.Size() -} -func (m *OutputView_Visible) XXX_DiscardUnknown() { - xxx_messageInfo_OutputView_Visible.DiscardUnknown(m) -} - -var xxx_messageInfo_OutputView_Visible proto.InternalMessageInfo -func (m *OutputView_Visible) GetOutput() *Output { - if m != nil { - return m.Output +func (m *ActionPlan) GetIbcRelayAction() *v1alpha17.IbcRelay { + if x, ok := m.GetAction().(*ActionPlan_IbcRelayAction); ok { + return x.IbcRelayAction } return nil } -func (m *OutputView_Visible) GetNote() *v1alpha1.NoteView { - if m != nil { - return m.Note +func (m *ActionPlan) GetProposalSubmit() *v1alpha18.ProposalSubmit { + if x, ok := m.GetAction().(*ActionPlan_ProposalSubmit); ok { + return x.ProposalSubmit } return nil } -func (m *OutputView_Visible) GetPayloadKey() *PayloadKey { - if m != nil { - return m.PayloadKey +func (m *ActionPlan) GetProposalWithdraw() *v1alpha18.ProposalWithdraw { + if x, ok := m.GetAction().(*ActionPlan_ProposalWithdraw); ok { + return x.ProposalWithdraw } return nil } -type OutputView_Opaque struct { - Output *Output `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"` +func (m *ActionPlan) GetValidatorVote() *v1alpha18.ValidatorVote { + if x, ok := m.GetAction().(*ActionPlan_ValidatorVote); ok { + return x.ValidatorVote + } + return nil } -func (m *OutputView_Opaque) Reset() { *m = OutputView_Opaque{} } -func (m *OutputView_Opaque) String() string { return proto.CompactTextString(m) } -func (*OutputView_Opaque) ProtoMessage() {} -func (*OutputView_Opaque) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{17, 1} -} -func (m *OutputView_Opaque) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *OutputView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_OutputView_Opaque.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 *ActionPlan) GetDelegatorVote() *v1alpha18.DelegatorVotePlan { + if x, ok := m.GetAction().(*ActionPlan_DelegatorVote); ok { + return x.DelegatorVote } + return nil } -func (m *OutputView_Opaque) XXX_Merge(src proto.Message) { - xxx_messageInfo_OutputView_Opaque.Merge(m, src) -} -func (m *OutputView_Opaque) XXX_Size() int { - return m.Size() -} -func (m *OutputView_Opaque) XXX_DiscardUnknown() { - xxx_messageInfo_OutputView_Opaque.DiscardUnknown(m) -} - -var xxx_messageInfo_OutputView_Opaque proto.InternalMessageInfo -func (m *OutputView_Opaque) GetOutput() *Output { - if m != nil { - return m.Output +func (m *ActionPlan) GetProposalDepositClaim() *v1alpha18.ProposalDepositClaim { + if x, ok := m.GetAction().(*ActionPlan_ProposalDepositClaim); ok { + return x.ProposalDepositClaim } return nil } -// Spends a shielded note. -type Spend struct { - // The effecting data of the spend. - Body *SpendBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` - // The authorizing signature for the spend. - AuthSig *v1alpha1.SpendAuthSignature `protobuf:"bytes,2,opt,name=auth_sig,json=authSig,proto3" json:"auth_sig,omitempty"` - // The proof that the spend is well-formed is authorizing data. - Proof *v1alpha1.ZKSpendProof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"` +func (m *ActionPlan) GetWithdrawal() *v1alpha17.Ics20Withdrawal { + if x, ok := m.GetAction().(*ActionPlan_Withdrawal); ok { + return x.Withdrawal + } + return nil } -func (m *Spend) Reset() { *m = Spend{} } -func (m *Spend) String() string { return proto.CompactTextString(m) } -func (*Spend) ProtoMessage() {} -func (*Spend) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{18} +func (m *ActionPlan) GetPositionOpen() *v1alpha15.PositionOpen { + if x, ok := m.GetAction().(*ActionPlan_PositionOpen); ok { + return x.PositionOpen + } + return nil } -func (m *Spend) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) + +func (m *ActionPlan) GetPositionClose() *v1alpha15.PositionClose { + if x, ok := m.GetAction().(*ActionPlan_PositionClose); ok { + return x.PositionClose + } + return nil } -func (m *Spend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Spend.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 *ActionPlan) GetPositionWithdraw() *v1alpha15.PositionWithdrawPlan { + if x, ok := m.GetAction().(*ActionPlan_PositionWithdraw); ok { + return x.PositionWithdraw } + return nil } -func (m *Spend) XXX_Merge(src proto.Message) { - xxx_messageInfo_Spend.Merge(m, src) + +func (m *ActionPlan) GetPositionRewardClaim() *v1alpha15.PositionRewardClaimPlan { + if x, ok := m.GetAction().(*ActionPlan_PositionRewardClaim); ok { + return x.PositionRewardClaim + } + return nil } -func (m *Spend) XXX_Size() int { - return m.Size() + +func (m *ActionPlan) GetDelegate() *v1alpha16.Delegate { + if x, ok := m.GetAction().(*ActionPlan_Delegate); ok { + return x.Delegate + } + return nil } -func (m *Spend) XXX_DiscardUnknown() { - xxx_messageInfo_Spend.DiscardUnknown(m) + +func (m *ActionPlan) GetUndelegate() *v1alpha16.Undelegate { + if x, ok := m.GetAction().(*ActionPlan_Undelegate); ok { + return x.Undelegate + } + return nil } -var xxx_messageInfo_Spend proto.InternalMessageInfo +func (m *ActionPlan) GetUndelegateClaim() *v1alpha16.UndelegateClaimPlan { + if x, ok := m.GetAction().(*ActionPlan_UndelegateClaim); ok { + return x.UndelegateClaim + } + return nil +} -func (m *Spend) GetBody() *SpendBody { - if m != nil { - return m.Body +func (m *ActionPlan) GetCommunityPoolSpend() *v1alpha18.CommunityPoolSpend { + if x, ok := m.GetAction().(*ActionPlan_CommunityPoolSpend); ok { + return x.CommunityPoolSpend } return nil } -func (m *Spend) GetAuthSig() *v1alpha1.SpendAuthSignature { - if m != nil { - return m.AuthSig +func (m *ActionPlan) GetCommunityPoolOutput() *v1alpha18.CommunityPoolOutput { + if x, ok := m.GetAction().(*ActionPlan_CommunityPoolOutput); ok { + return x.CommunityPoolOutput } return nil } -func (m *Spend) GetProof() *v1alpha1.ZKSpendProof { - if m != nil { - return m.Proof +func (m *ActionPlan) GetCommunityPoolDeposit() *v1alpha18.CommunityPoolDeposit { + if x, ok := m.GetAction().(*ActionPlan_CommunityPoolDeposit); ok { + return x.CommunityPoolDeposit } return nil } -// The body of a spend description, containing only the effecting data -// describing changes to the ledger, and not the authorizing data that allows -// those changes to be performed. -type SpendBody struct { - // A commitment to the value of the input note. - BalanceCommitment *v1alpha1.BalanceCommitment `protobuf:"bytes,1,opt,name=balance_commitment,json=balanceCommitment,proto3" json:"balance_commitment,omitempty"` - // The nullifier of the input note. - Nullifier []byte `protobuf:"bytes,3,opt,name=nullifier,proto3" json:"nullifier,omitempty"` - // The randomized validating key for the spend authorization signature. - Rk []byte `protobuf:"bytes,4,opt,name=rk,proto3" json:"rk,omitempty"` +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ActionPlan) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ActionPlan_Spend)(nil), + (*ActionPlan_Output)(nil), + (*ActionPlan_Swap)(nil), + (*ActionPlan_SwapClaim)(nil), + (*ActionPlan_ValidatorDefinition)(nil), + (*ActionPlan_IbcRelayAction)(nil), + (*ActionPlan_ProposalSubmit)(nil), + (*ActionPlan_ProposalWithdraw)(nil), + (*ActionPlan_ValidatorVote)(nil), + (*ActionPlan_DelegatorVote)(nil), + (*ActionPlan_ProposalDepositClaim)(nil), + (*ActionPlan_Withdrawal)(nil), + (*ActionPlan_PositionOpen)(nil), + (*ActionPlan_PositionClose)(nil), + (*ActionPlan_PositionWithdraw)(nil), + (*ActionPlan_PositionRewardClaim)(nil), + (*ActionPlan_Delegate)(nil), + (*ActionPlan_Undelegate)(nil), + (*ActionPlan_UndelegateClaim)(nil), + (*ActionPlan_CommunityPoolSpend)(nil), + (*ActionPlan_CommunityPoolOutput)(nil), + (*ActionPlan_CommunityPoolDeposit)(nil), + } } -func (m *SpendBody) Reset() { *m = SpendBody{} } -func (m *SpendBody) String() string { return proto.CompactTextString(m) } -func (*SpendBody) ProtoMessage() {} -func (*SpendBody) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{19} +// Describes a plan for forming a `Clue`. +type CluePlan struct { + // The address. + Address *v1alpha19.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // The random seed to use for the clue plan. + Rseed []byte `protobuf:"bytes,2,opt,name=rseed,proto3" json:"rseed,omitempty"` + // The bits of precision. + PrecisionBits uint64 `protobuf:"varint,3,opt,name=precision_bits,json=precisionBits,proto3" json:"precision_bits,omitempty"` +} + +func (m *CluePlan) Reset() { *m = CluePlan{} } +func (m *CluePlan) String() string { return proto.CompactTextString(m) } +func (*CluePlan) ProtoMessage() {} +func (*CluePlan) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{16} } -func (m *SpendBody) XXX_Unmarshal(b []byte) error { +func (m *CluePlan) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SpendBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *CluePlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SpendBody.Marshal(b, m, deterministic) + return xxx_messageInfo_CluePlan.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2214,59 +1937,59 @@ func (m *SpendBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *SpendBody) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpendBody.Merge(m, src) +func (m *CluePlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_CluePlan.Merge(m, src) } -func (m *SpendBody) XXX_Size() int { +func (m *CluePlan) XXX_Size() int { return m.Size() } -func (m *SpendBody) XXX_DiscardUnknown() { - xxx_messageInfo_SpendBody.DiscardUnknown(m) +func (m *CluePlan) XXX_DiscardUnknown() { + xxx_messageInfo_CluePlan.DiscardUnknown(m) } -var xxx_messageInfo_SpendBody proto.InternalMessageInfo +var xxx_messageInfo_CluePlan proto.InternalMessageInfo -func (m *SpendBody) GetBalanceCommitment() *v1alpha1.BalanceCommitment { +func (m *CluePlan) GetAddress() *v1alpha19.Address { if m != nil { - return m.BalanceCommitment + return m.Address } return nil } -func (m *SpendBody) GetNullifier() []byte { +func (m *CluePlan) GetRseed() []byte { if m != nil { - return m.Nullifier + return m.Rseed } return nil } -func (m *SpendBody) GetRk() []byte { +func (m *CluePlan) GetPrecisionBits() uint64 { if m != nil { - return m.Rk + return m.PrecisionBits } - return nil + return 0 } -// Creates a new shielded note. -type Output struct { - // The effecting data for the output. - Body *OutputBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"` - // The output proof is authorizing data. - Proof *v1alpha1.ZKOutputProof `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` +// Describes a plan for forming the transaction memo. +type MemoPlan struct { + // The plaintext. + Plaintext *MemoPlaintext `protobuf:"bytes,1,opt,name=plaintext,proto3" json:"plaintext,omitempty"` + // The key to use to encrypt the memo. + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` } -func (m *Output) Reset() { *m = Output{} } -func (m *Output) String() string { return proto.CompactTextString(m) } -func (*Output) ProtoMessage() {} -func (*Output) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{20} +func (m *MemoPlan) Reset() { *m = MemoPlan{} } +func (m *MemoPlan) String() string { return proto.CompactTextString(m) } +func (*MemoPlan) ProtoMessage() {} +func (*MemoPlan) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{17} } -func (m *Output) XXX_Unmarshal(b []byte) error { +func (m *MemoPlan) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *Output) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MemoPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_Output.Marshal(b, m, deterministic) + return xxx_messageInfo_MemoPlan.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2276,59 +1999,50 @@ func (m *Output) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *Output) XXX_Merge(src proto.Message) { - xxx_messageInfo_Output.Merge(m, src) +func (m *MemoPlan) XXX_Merge(src proto.Message) { + xxx_messageInfo_MemoPlan.Merge(m, src) } -func (m *Output) XXX_Size() int { +func (m *MemoPlan) XXX_Size() int { return m.Size() } -func (m *Output) XXX_DiscardUnknown() { - xxx_messageInfo_Output.DiscardUnknown(m) +func (m *MemoPlan) XXX_DiscardUnknown() { + xxx_messageInfo_MemoPlan.DiscardUnknown(m) } -var xxx_messageInfo_Output proto.InternalMessageInfo +var xxx_messageInfo_MemoPlan proto.InternalMessageInfo -func (m *Output) GetBody() *OutputBody { +func (m *MemoPlan) GetPlaintext() *MemoPlaintext { if m != nil { - return m.Body + return m.Plaintext } return nil } -func (m *Output) GetProof() *v1alpha1.ZKOutputProof { +func (m *MemoPlan) GetKey() []byte { if m != nil { - return m.Proof + return m.Key } return nil } -// The body of an output description, containing only the effecting data -// describing changes to the ledger, and not the authorizing data that allows -// those changes to be performed. -type OutputBody struct { - // The minimal data required to scan and process the new output note. - NotePayload *v1alpha1.NotePayload `protobuf:"bytes,1,opt,name=note_payload,json=notePayload,proto3" json:"note_payload,omitempty"` - // A commitment to the value of the output note. 32 bytes. - BalanceCommitment *v1alpha1.BalanceCommitment `protobuf:"bytes,2,opt,name=balance_commitment,json=balanceCommitment,proto3" json:"balance_commitment,omitempty"` - // An encrypted key for decrypting the memo. - WrappedMemoKey []byte `protobuf:"bytes,3,opt,name=wrapped_memo_key,json=wrappedMemoKey,proto3" json:"wrapped_memo_key,omitempty"` - // The key material used for note encryption, wrapped in encryption to the - // sender's outgoing viewing key. 80 bytes. - OvkWrappedKey []byte `protobuf:"bytes,4,opt,name=ovk_wrapped_key,json=ovkWrappedKey,proto3" json:"ovk_wrapped_key,omitempty"` -} - -func (m *OutputBody) Reset() { *m = OutputBody{} } -func (m *OutputBody) String() string { return proto.CompactTextString(m) } -func (*OutputBody) ProtoMessage() {} -func (*OutputBody) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{21} +// The encrypted memo data describing information about the purpose of a transaction. +type MemoCiphertext struct { + // The encrypted data. 528 bytes. + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *MemoCiphertext) Reset() { *m = MemoCiphertext{} } +func (m *MemoCiphertext) String() string { return proto.CompactTextString(m) } +func (*MemoCiphertext) ProtoMessage() {} +func (*MemoCiphertext) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{18} } -func (m *OutputBody) XXX_Unmarshal(b []byte) error { +func (m *MemoCiphertext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *OutputBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MemoCiphertext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_OutputBody.Marshal(b, m, deterministic) + return xxx_messageInfo_MemoCiphertext.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2338,70 +2052,48 @@ func (m *OutputBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *OutputBody) XXX_Merge(src proto.Message) { - xxx_messageInfo_OutputBody.Merge(m, src) +func (m *MemoCiphertext) XXX_Merge(src proto.Message) { + xxx_messageInfo_MemoCiphertext.Merge(m, src) } -func (m *OutputBody) XXX_Size() int { +func (m *MemoCiphertext) XXX_Size() int { return m.Size() } -func (m *OutputBody) XXX_DiscardUnknown() { - xxx_messageInfo_OutputBody.DiscardUnknown(m) -} - -var xxx_messageInfo_OutputBody proto.InternalMessageInfo - -func (m *OutputBody) GetNotePayload() *v1alpha1.NotePayload { - if m != nil { - return m.NotePayload - } - return nil -} - -func (m *OutputBody) GetBalanceCommitment() *v1alpha1.BalanceCommitment { - if m != nil { - return m.BalanceCommitment - } - return nil +func (m *MemoCiphertext) XXX_DiscardUnknown() { + xxx_messageInfo_MemoCiphertext.DiscardUnknown(m) } -func (m *OutputBody) GetWrappedMemoKey() []byte { - if m != nil { - return m.WrappedMemoKey - } - return nil -} +var xxx_messageInfo_MemoCiphertext proto.InternalMessageInfo -func (m *OutputBody) GetOvkWrappedKey() []byte { +func (m *MemoCiphertext) GetInner() []byte { if m != nil { - return m.OvkWrappedKey + return m.Inner } return nil } -// The data required to authorize a transaction plan. -type AuthorizationData struct { - // The computed auth hash for the approved transaction plan. - EffectHash *v1alpha1.EffectHash `protobuf:"bytes,1,opt,name=effect_hash,json=effectHash,proto3" json:"effect_hash,omitempty"` - // The required spend authorizations, returned in the same order as the - // Spend actions in the original request. - SpendAuths []*v1alpha1.SpendAuthSignature `protobuf:"bytes,2,rep,name=spend_auths,json=spendAuths,proto3" json:"spend_auths,omitempty"` - // The required delegator vote authorizations, returned in the same order as the - // DelegatorVote actions in the original request. - DelegatorVoteAuths []*v1alpha1.SpendAuthSignature `protobuf:"bytes,3,rep,name=delegator_vote_auths,json=delegatorVoteAuths,proto3" json:"delegator_vote_auths,omitempty"` +// The plaintext describing information about the purpose of a transaction. +type MemoPlaintext struct { + // The sender's return address. + // + // This should always be a valid address; the sender is responsible for ensuring + // that if the receiver returns funds to this address, they will not be lost. + ReturnAddress *v1alpha19.Address `protobuf:"bytes,1,opt,name=return_address,json=returnAddress,proto3" json:"return_address,omitempty"` + // Free-form text, up to 432 bytes long. + Text string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"` } -func (m *AuthorizationData) Reset() { *m = AuthorizationData{} } -func (m *AuthorizationData) String() string { return proto.CompactTextString(m) } -func (*AuthorizationData) ProtoMessage() {} -func (*AuthorizationData) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{22} +func (m *MemoPlaintext) Reset() { *m = MemoPlaintext{} } +func (m *MemoPlaintext) String() string { return proto.CompactTextString(m) } +func (*MemoPlaintext) ProtoMessage() {} +func (*MemoPlaintext) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{19} } -func (m *AuthorizationData) XXX_Unmarshal(b []byte) error { +func (m *MemoPlaintext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *AuthorizationData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MemoPlaintext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_AuthorizationData.Marshal(b, m, deterministic) + return xxx_messageInfo_MemoPlaintext.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2411,60 +2103,49 @@ func (m *AuthorizationData) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } -func (m *AuthorizationData) XXX_Merge(src proto.Message) { - xxx_messageInfo_AuthorizationData.Merge(m, src) +func (m *MemoPlaintext) XXX_Merge(src proto.Message) { + xxx_messageInfo_MemoPlaintext.Merge(m, src) } -func (m *AuthorizationData) XXX_Size() int { +func (m *MemoPlaintext) XXX_Size() int { return m.Size() } -func (m *AuthorizationData) XXX_DiscardUnknown() { - xxx_messageInfo_AuthorizationData.DiscardUnknown(m) +func (m *MemoPlaintext) XXX_DiscardUnknown() { + xxx_messageInfo_MemoPlaintext.DiscardUnknown(m) } -var xxx_messageInfo_AuthorizationData proto.InternalMessageInfo - -func (m *AuthorizationData) GetEffectHash() *v1alpha1.EffectHash { - if m != nil { - return m.EffectHash - } - return nil -} +var xxx_messageInfo_MemoPlaintext proto.InternalMessageInfo -func (m *AuthorizationData) GetSpendAuths() []*v1alpha1.SpendAuthSignature { +func (m *MemoPlaintext) GetReturnAddress() *v1alpha19.Address { if m != nil { - return m.SpendAuths + return m.ReturnAddress } return nil } -func (m *AuthorizationData) GetDelegatorVoteAuths() []*v1alpha1.SpendAuthSignature { +func (m *MemoPlaintext) GetText() string { if m != nil { - return m.DelegatorVoteAuths + return m.Text } - return nil + return "" } -// The data required for proving when building a transaction from a plan. -type WitnessData struct { - // The anchor for the state transition proofs. - Anchor *v1alpha1.MerkleRoot `protobuf:"bytes,1,opt,name=anchor,proto3" json:"anchor,omitempty"` - // The auth paths for the notes the transaction spends, in the - // same order as the spends in the transaction plan. - StateCommitmentProofs []*v1alpha1.StateCommitmentProof `protobuf:"bytes,2,rep,name=state_commitment_proofs,json=stateCommitmentProofs,proto3" json:"state_commitment_proofs,omitempty"` +type MemoPlaintextView struct { + ReturnAddress *v1alpha19.AddressView `protobuf:"bytes,1,opt,name=return_address,json=returnAddress,proto3" json:"return_address,omitempty"` + Text string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"` } -func (m *WitnessData) Reset() { *m = WitnessData{} } -func (m *WitnessData) String() string { return proto.CompactTextString(m) } -func (*WitnessData) ProtoMessage() {} -func (*WitnessData) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{23} +func (m *MemoPlaintextView) Reset() { *m = MemoPlaintextView{} } +func (m *MemoPlaintextView) String() string { return proto.CompactTextString(m) } +func (*MemoPlaintextView) ProtoMessage() {} +func (*MemoPlaintextView) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{20} } -func (m *WitnessData) XXX_Unmarshal(b []byte) error { +func (m *MemoPlaintextView) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *WitnessData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MemoPlaintextView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_WitnessData.Marshal(b, m, deterministic) + return xxx_messageInfo_MemoPlaintextView.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2474,60 +2155,52 @@ func (m *WitnessData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } -func (m *WitnessData) XXX_Merge(src proto.Message) { - xxx_messageInfo_WitnessData.Merge(m, src) +func (m *MemoPlaintextView) XXX_Merge(src proto.Message) { + xxx_messageInfo_MemoPlaintextView.Merge(m, src) } -func (m *WitnessData) XXX_Size() int { +func (m *MemoPlaintextView) XXX_Size() int { return m.Size() } -func (m *WitnessData) XXX_DiscardUnknown() { - xxx_messageInfo_WitnessData.DiscardUnknown(m) +func (m *MemoPlaintextView) XXX_DiscardUnknown() { + xxx_messageInfo_MemoPlaintextView.DiscardUnknown(m) } -var xxx_messageInfo_WitnessData proto.InternalMessageInfo +var xxx_messageInfo_MemoPlaintextView proto.InternalMessageInfo -func (m *WitnessData) GetAnchor() *v1alpha1.MerkleRoot { +func (m *MemoPlaintextView) GetReturnAddress() *v1alpha19.AddressView { if m != nil { - return m.Anchor + return m.ReturnAddress } return nil } -func (m *WitnessData) GetStateCommitmentProofs() []*v1alpha1.StateCommitmentProof { +func (m *MemoPlaintextView) GetText() string { if m != nil { - return m.StateCommitmentProofs + return m.Text } - return nil + return "" } -// Describes a planned transaction. Permits clients to prepare a transaction -// prior submission, so that a user can review it prior to authorizing its execution. -type TransactionPlan struct { - // The planner interface(s) for Actions to be performed, such as a Spend, Swap, - // or Delegation. See the ActionPlan docs for a full list of options. - Actions []*ActionPlan `protobuf:"bytes,1,rep,name=actions,proto3" json:"actions,omitempty"` - // Time, as block height, after which TransactionPlan should be considered invalid. - ExpiryHeight uint64 `protobuf:"varint,2,opt,name=expiry_height,json=expiryHeight,proto3" json:"expiry_height,omitempty"` - // The name of the network for which this TransactionPlan was built. - ChainId string `protobuf:"bytes,3,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` - Fee *v1alpha1.Fee `protobuf:"bytes,4,opt,name=fee,proto3" json:"fee,omitempty"` - CluePlans []*CluePlan `protobuf:"bytes,5,rep,name=clue_plans,json=cluePlans,proto3" json:"clue_plans,omitempty"` - // Planning interface for constructing an optional Memo for the Transaction. - MemoPlan *MemoPlan `protobuf:"bytes,6,opt,name=memo_plan,json=memoPlan,proto3" json:"memo_plan,omitempty"` +type MemoView struct { + // Types that are valid to be assigned to MemoView: + // + // *MemoView_Visible_ + // *MemoView_Opaque_ + MemoView isMemoView_MemoView `protobuf_oneof:"memo_view"` } -func (m *TransactionPlan) Reset() { *m = TransactionPlan{} } -func (m *TransactionPlan) String() string { return proto.CompactTextString(m) } -func (*TransactionPlan) ProtoMessage() {} -func (*TransactionPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{24} +func (m *MemoView) Reset() { *m = MemoView{} } +func (m *MemoView) String() string { return proto.CompactTextString(m) } +func (*MemoView) ProtoMessage() {} +func (*MemoView) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{21} } -func (m *TransactionPlan) XXX_Unmarshal(b []byte) error { +func (m *MemoView) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *TransactionPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MemoView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_TransactionPlan.Marshal(b, m, deterministic) + return xxx_messageInfo_MemoView.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2537,104 +2210,80 @@ func (m *TransactionPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } -func (m *TransactionPlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_TransactionPlan.Merge(m, src) +func (m *MemoView) XXX_Merge(src proto.Message) { + xxx_messageInfo_MemoView.Merge(m, src) } -func (m *TransactionPlan) XXX_Size() int { +func (m *MemoView) XXX_Size() int { return m.Size() } -func (m *TransactionPlan) XXX_DiscardUnknown() { - xxx_messageInfo_TransactionPlan.DiscardUnknown(m) +func (m *MemoView) XXX_DiscardUnknown() { + xxx_messageInfo_MemoView.DiscardUnknown(m) } -var xxx_messageInfo_TransactionPlan proto.InternalMessageInfo +var xxx_messageInfo_MemoView proto.InternalMessageInfo -func (m *TransactionPlan) GetActions() []*ActionPlan { - if m != nil { - return m.Actions - } - return nil +type isMemoView_MemoView interface { + isMemoView_MemoView() + MarshalTo([]byte) (int, error) + Size() int } -func (m *TransactionPlan) GetExpiryHeight() uint64 { - if m != nil { - return m.ExpiryHeight - } - return 0 +type MemoView_Visible_ struct { + Visible *MemoView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` } +type MemoView_Opaque_ struct { + Opaque *MemoView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +} + +func (*MemoView_Visible_) isMemoView_MemoView() {} +func (*MemoView_Opaque_) isMemoView_MemoView() {} -func (m *TransactionPlan) GetChainId() string { +func (m *MemoView) GetMemoView() isMemoView_MemoView { if m != nil { - return m.ChainId + return m.MemoView } - return "" + return nil } -func (m *TransactionPlan) GetFee() *v1alpha1.Fee { - if m != nil { - return m.Fee +func (m *MemoView) GetVisible() *MemoView_Visible { + if x, ok := m.GetMemoView().(*MemoView_Visible_); ok { + return x.Visible } return nil } -func (m *TransactionPlan) GetCluePlans() []*CluePlan { - if m != nil { - return m.CluePlans +func (m *MemoView) GetOpaque() *MemoView_Opaque { + if x, ok := m.GetMemoView().(*MemoView_Opaque_); ok { + return x.Opaque } return nil } -func (m *TransactionPlan) GetMemoPlan() *MemoPlan { - if m != nil { - return m.MemoPlan +// XXX_OneofWrappers is for the internal use of the proto package. +func (*MemoView) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*MemoView_Visible_)(nil), + (*MemoView_Opaque_)(nil), } - return nil } -// Describes a planned transaction action. -// -// Some transaction Actions don't have any private data and are treated as being plans -// themselves. -type ActionPlan struct { - // Types that are valid to be assigned to Action: - // - // *ActionPlan_Spend - // *ActionPlan_Output - // *ActionPlan_Swap - // *ActionPlan_SwapClaim - // *ActionPlan_ValidatorDefinition - // *ActionPlan_IbcAction - // *ActionPlan_ProposalSubmit - // *ActionPlan_ProposalWithdraw - // *ActionPlan_ValidatorVote - // *ActionPlan_DelegatorVote - // *ActionPlan_ProposalDepositClaim - // *ActionPlan_Withdrawal - // *ActionPlan_PositionOpen - // *ActionPlan_PositionClose - // *ActionPlan_PositionWithdraw - // *ActionPlan_PositionRewardClaim - // *ActionPlan_Delegate - // *ActionPlan_Undelegate - // *ActionPlan_UndelegateClaim - // *ActionPlan_DaoSpend - // *ActionPlan_DaoOutput - // *ActionPlan_DaoDeposit - Action isActionPlan_Action `protobuf_oneof:"action"` +type MemoView_Visible struct { + Ciphertext *MemoCiphertext `protobuf:"bytes,1,opt,name=ciphertext,proto3" json:"ciphertext,omitempty"` + Plaintext *MemoPlaintextView `protobuf:"bytes,2,opt,name=plaintext,proto3" json:"plaintext,omitempty"` } -func (m *ActionPlan) Reset() { *m = ActionPlan{} } -func (m *ActionPlan) String() string { return proto.CompactTextString(m) } -func (*ActionPlan) ProtoMessage() {} -func (*ActionPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{25} +func (m *MemoView_Visible) Reset() { *m = MemoView_Visible{} } +func (m *MemoView_Visible) String() string { return proto.CompactTextString(m) } +func (*MemoView_Visible) ProtoMessage() {} +func (*MemoView_Visible) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{21, 0} } -func (m *ActionPlan) XXX_Unmarshal(b []byte) error { +func (m *MemoView_Visible) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ActionPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MemoView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ActionPlan.Marshal(b, m, deterministic) + return xxx_messageInfo_MemoView_Visible.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2644,1108 +2293,1112 @@ func (m *ActionPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *ActionPlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_ActionPlan.Merge(m, src) +func (m *MemoView_Visible) XXX_Merge(src proto.Message) { + xxx_messageInfo_MemoView_Visible.Merge(m, src) } -func (m *ActionPlan) XXX_Size() int { +func (m *MemoView_Visible) XXX_Size() int { return m.Size() } -func (m *ActionPlan) XXX_DiscardUnknown() { - xxx_messageInfo_ActionPlan.DiscardUnknown(m) +func (m *MemoView_Visible) XXX_DiscardUnknown() { + xxx_messageInfo_MemoView_Visible.DiscardUnknown(m) } -var xxx_messageInfo_ActionPlan proto.InternalMessageInfo +var xxx_messageInfo_MemoView_Visible proto.InternalMessageInfo -type isActionPlan_Action interface { - isActionPlan_Action() - MarshalTo([]byte) (int, error) - Size() int +func (m *MemoView_Visible) GetCiphertext() *MemoCiphertext { + if m != nil { + return m.Ciphertext + } + return nil } -type ActionPlan_Spend struct { - Spend *SpendPlan `protobuf:"bytes,1,opt,name=spend,proto3,oneof" json:"spend,omitempty"` -} -type ActionPlan_Output struct { - Output *OutputPlan `protobuf:"bytes,2,opt,name=output,proto3,oneof" json:"output,omitempty"` -} -type ActionPlan_Swap struct { - Swap *v1alpha11.SwapPlan `protobuf:"bytes,3,opt,name=swap,proto3,oneof" json:"swap,omitempty"` -} -type ActionPlan_SwapClaim struct { - SwapClaim *v1alpha11.SwapClaimPlan `protobuf:"bytes,4,opt,name=swap_claim,json=swapClaim,proto3,oneof" json:"swap_claim,omitempty"` -} -type ActionPlan_ValidatorDefinition struct { - ValidatorDefinition *v1alpha12.ValidatorDefinition `protobuf:"bytes,16,opt,name=validator_definition,json=validatorDefinition,proto3,oneof" json:"validator_definition,omitempty"` -} -type ActionPlan_IbcAction struct { - IbcAction *v1alpha13.IbcAction `protobuf:"bytes,17,opt,name=ibc_action,json=ibcAction,proto3,oneof" json:"ibc_action,omitempty"` -} -type ActionPlan_ProposalSubmit struct { - ProposalSubmit *v1alpha14.ProposalSubmit `protobuf:"bytes,18,opt,name=proposal_submit,json=proposalSubmit,proto3,oneof" json:"proposal_submit,omitempty"` -} -type ActionPlan_ProposalWithdraw struct { - ProposalWithdraw *v1alpha14.ProposalWithdraw `protobuf:"bytes,19,opt,name=proposal_withdraw,json=proposalWithdraw,proto3,oneof" json:"proposal_withdraw,omitempty"` -} -type ActionPlan_ValidatorVote struct { - ValidatorVote *v1alpha14.ValidatorVote `protobuf:"bytes,20,opt,name=validator_vote,json=validatorVote,proto3,oneof" json:"validator_vote,omitempty"` -} -type ActionPlan_DelegatorVote struct { - DelegatorVote *v1alpha14.DelegatorVotePlan `protobuf:"bytes,21,opt,name=delegator_vote,json=delegatorVote,proto3,oneof" json:"delegator_vote,omitempty"` -} -type ActionPlan_ProposalDepositClaim struct { - ProposalDepositClaim *v1alpha14.ProposalDepositClaim `protobuf:"bytes,22,opt,name=proposal_deposit_claim,json=proposalDepositClaim,proto3,oneof" json:"proposal_deposit_claim,omitempty"` -} -type ActionPlan_Withdrawal struct { - Withdrawal *v1alpha13.Ics20Withdrawal `protobuf:"bytes,23,opt,name=withdrawal,proto3,oneof" json:"withdrawal,omitempty"` -} -type ActionPlan_PositionOpen struct { - PositionOpen *v1alpha11.PositionOpen `protobuf:"bytes,30,opt,name=position_open,json=positionOpen,proto3,oneof" json:"position_open,omitempty"` -} -type ActionPlan_PositionClose struct { - PositionClose *v1alpha11.PositionClose `protobuf:"bytes,31,opt,name=position_close,json=positionClose,proto3,oneof" json:"position_close,omitempty"` -} -type ActionPlan_PositionWithdraw struct { - PositionWithdraw *v1alpha11.PositionWithdrawPlan `protobuf:"bytes,32,opt,name=position_withdraw,json=positionWithdraw,proto3,oneof" json:"position_withdraw,omitempty"` +func (m *MemoView_Visible) GetPlaintext() *MemoPlaintextView { + if m != nil { + return m.Plaintext + } + return nil } -type ActionPlan_PositionRewardClaim struct { - PositionRewardClaim *v1alpha11.PositionRewardClaimPlan `protobuf:"bytes,34,opt,name=position_reward_claim,json=positionRewardClaim,proto3,oneof" json:"position_reward_claim,omitempty"` + +type MemoView_Opaque struct { + Ciphertext *MemoCiphertext `protobuf:"bytes,1,opt,name=ciphertext,proto3" json:"ciphertext,omitempty"` } -type ActionPlan_Delegate struct { - Delegate *v1alpha12.Delegate `protobuf:"bytes,40,opt,name=delegate,proto3,oneof" json:"delegate,omitempty"` + +func (m *MemoView_Opaque) Reset() { *m = MemoView_Opaque{} } +func (m *MemoView_Opaque) String() string { return proto.CompactTextString(m) } +func (*MemoView_Opaque) ProtoMessage() {} +func (*MemoView_Opaque) Descriptor() ([]byte, []int) { + return fileDescriptor_cd20ea79758052c4, []int{21, 1} } -type ActionPlan_Undelegate struct { - Undelegate *v1alpha12.Undelegate `protobuf:"bytes,41,opt,name=undelegate,proto3,oneof" json:"undelegate,omitempty"` +func (m *MemoView_Opaque) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } -type ActionPlan_UndelegateClaim struct { - UndelegateClaim *v1alpha12.UndelegateClaimPlan `protobuf:"bytes,42,opt,name=undelegate_claim,json=undelegateClaim,proto3,oneof" json:"undelegate_claim,omitempty"` +func (m *MemoView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MemoView_Opaque.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } -type ActionPlan_DaoSpend struct { - DaoSpend *v1alpha14.DaoSpend `protobuf:"bytes,50,opt,name=dao_spend,json=daoSpend,proto3,oneof" json:"dao_spend,omitempty"` +func (m *MemoView_Opaque) XXX_Merge(src proto.Message) { + xxx_messageInfo_MemoView_Opaque.Merge(m, src) } -type ActionPlan_DaoOutput struct { - DaoOutput *v1alpha14.DaoOutput `protobuf:"bytes,51,opt,name=dao_output,json=daoOutput,proto3,oneof" json:"dao_output,omitempty"` +func (m *MemoView_Opaque) XXX_Size() int { + return m.Size() } -type ActionPlan_DaoDeposit struct { - DaoDeposit *v1alpha14.DaoDeposit `protobuf:"bytes,52,opt,name=dao_deposit,json=daoDeposit,proto3,oneof" json:"dao_deposit,omitempty"` +func (m *MemoView_Opaque) XXX_DiscardUnknown() { + xxx_messageInfo_MemoView_Opaque.DiscardUnknown(m) } -func (*ActionPlan_Spend) isActionPlan_Action() {} -func (*ActionPlan_Output) isActionPlan_Action() {} -func (*ActionPlan_Swap) isActionPlan_Action() {} -func (*ActionPlan_SwapClaim) isActionPlan_Action() {} -func (*ActionPlan_ValidatorDefinition) isActionPlan_Action() {} -func (*ActionPlan_IbcAction) isActionPlan_Action() {} -func (*ActionPlan_ProposalSubmit) isActionPlan_Action() {} -func (*ActionPlan_ProposalWithdraw) isActionPlan_Action() {} -func (*ActionPlan_ValidatorVote) isActionPlan_Action() {} -func (*ActionPlan_DelegatorVote) isActionPlan_Action() {} -func (*ActionPlan_ProposalDepositClaim) isActionPlan_Action() {} -func (*ActionPlan_Withdrawal) isActionPlan_Action() {} -func (*ActionPlan_PositionOpen) isActionPlan_Action() {} -func (*ActionPlan_PositionClose) isActionPlan_Action() {} -func (*ActionPlan_PositionWithdraw) isActionPlan_Action() {} -func (*ActionPlan_PositionRewardClaim) isActionPlan_Action() {} -func (*ActionPlan_Delegate) isActionPlan_Action() {} -func (*ActionPlan_Undelegate) isActionPlan_Action() {} -func (*ActionPlan_UndelegateClaim) isActionPlan_Action() {} -func (*ActionPlan_DaoSpend) isActionPlan_Action() {} -func (*ActionPlan_DaoOutput) isActionPlan_Action() {} -func (*ActionPlan_DaoDeposit) isActionPlan_Action() {} +var xxx_messageInfo_MemoView_Opaque proto.InternalMessageInfo -func (m *ActionPlan) GetAction() isActionPlan_Action { +func (m *MemoView_Opaque) GetCiphertext() *MemoCiphertext { if m != nil { - return m.Action - } - return nil -} - -func (m *ActionPlan) GetSpend() *SpendPlan { - if x, ok := m.GetAction().(*ActionPlan_Spend); ok { - return x.Spend - } - return nil -} - -func (m *ActionPlan) GetOutput() *OutputPlan { - if x, ok := m.GetAction().(*ActionPlan_Output); ok { - return x.Output - } - return nil -} - -func (m *ActionPlan) GetSwap() *v1alpha11.SwapPlan { - if x, ok := m.GetAction().(*ActionPlan_Swap); ok { - return x.Swap + return m.Ciphertext } return nil } -func (m *ActionPlan) GetSwapClaim() *v1alpha11.SwapClaimPlan { - if x, ok := m.GetAction().(*ActionPlan_SwapClaim); ok { - return x.SwapClaim - } - return nil +func init() { + proto.RegisterType((*Transaction)(nil), "penumbra.core.transaction.v1alpha1.Transaction") + proto.RegisterType((*TransactionBody)(nil), "penumbra.core.transaction.v1alpha1.TransactionBody") + proto.RegisterType((*TransactionParameters)(nil), "penumbra.core.transaction.v1alpha1.TransactionParameters") + proto.RegisterType((*DetectionData)(nil), "penumbra.core.transaction.v1alpha1.DetectionData") + proto.RegisterType((*Action)(nil), "penumbra.core.transaction.v1alpha1.Action") + proto.RegisterType((*TransactionPerspective)(nil), "penumbra.core.transaction.v1alpha1.TransactionPerspective") + proto.RegisterType((*PayloadKeyWithCommitment)(nil), "penumbra.core.transaction.v1alpha1.PayloadKeyWithCommitment") + proto.RegisterType((*NullifierWithNote)(nil), "penumbra.core.transaction.v1alpha1.NullifierWithNote") + proto.RegisterType((*TransactionView)(nil), "penumbra.core.transaction.v1alpha1.TransactionView") + proto.RegisterType((*TransactionBodyView)(nil), "penumbra.core.transaction.v1alpha1.TransactionBodyView") + proto.RegisterType((*ActionView)(nil), "penumbra.core.transaction.v1alpha1.ActionView") + proto.RegisterType((*AuthorizationData)(nil), "penumbra.core.transaction.v1alpha1.AuthorizationData") + proto.RegisterType((*WitnessData)(nil), "penumbra.core.transaction.v1alpha1.WitnessData") + proto.RegisterType((*TransactionPlan)(nil), "penumbra.core.transaction.v1alpha1.TransactionPlan") + proto.RegisterType((*DetectionDataPlan)(nil), "penumbra.core.transaction.v1alpha1.DetectionDataPlan") + proto.RegisterType((*ActionPlan)(nil), "penumbra.core.transaction.v1alpha1.ActionPlan") + proto.RegisterType((*CluePlan)(nil), "penumbra.core.transaction.v1alpha1.CluePlan") + proto.RegisterType((*MemoPlan)(nil), "penumbra.core.transaction.v1alpha1.MemoPlan") + proto.RegisterType((*MemoCiphertext)(nil), "penumbra.core.transaction.v1alpha1.MemoCiphertext") + proto.RegisterType((*MemoPlaintext)(nil), "penumbra.core.transaction.v1alpha1.MemoPlaintext") + proto.RegisterType((*MemoPlaintextView)(nil), "penumbra.core.transaction.v1alpha1.MemoPlaintextView") + proto.RegisterType((*MemoView)(nil), "penumbra.core.transaction.v1alpha1.MemoView") + proto.RegisterType((*MemoView_Visible)(nil), "penumbra.core.transaction.v1alpha1.MemoView.Visible") + proto.RegisterType((*MemoView_Opaque)(nil), "penumbra.core.transaction.v1alpha1.MemoView.Opaque") } -func (m *ActionPlan) GetValidatorDefinition() *v1alpha12.ValidatorDefinition { - if x, ok := m.GetAction().(*ActionPlan_ValidatorDefinition); ok { - return x.ValidatorDefinition - } - return nil +func init() { + proto.RegisterFile("penumbra/core/transaction/v1alpha1/transaction.proto", fileDescriptor_cd20ea79758052c4) } -func (m *ActionPlan) GetIbcAction() *v1alpha13.IbcAction { - if x, ok := m.GetAction().(*ActionPlan_IbcAction); ok { - return x.IbcAction - } - return nil +var fileDescriptor_cd20ea79758052c4 = []byte{ + // 2370 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcf, 0x73, 0x1c, 0x47, + 0xf5, 0xdf, 0x95, 0x64, 0x59, 0x7a, 0xab, 0x95, 0xa5, 0xb6, 0xe4, 0xec, 0xd7, 0x07, 0x7d, 0x5d, + 0x0b, 0x31, 0xb2, 0x03, 0xab, 0x58, 0x72, 0x70, 0xb2, 0x4e, 0x82, 0x2d, 0x89, 0x64, 0x8d, 0x4b, + 0xf6, 0x66, 0x24, 0x6c, 0x1c, 0x54, 0x35, 0xe9, 0x9d, 0xe9, 0xd5, 0x36, 0x9e, 0x9d, 0x1e, 0xa6, + 0x7b, 0x57, 0x5a, 0xce, 0x54, 0x71, 0xe5, 0xc0, 0x89, 0x2a, 0x2e, 0x1c, 0x53, 0x9c, 0xc2, 0x81, + 0x03, 0xff, 0x40, 0x0a, 0x2e, 0x39, 0x72, 0x04, 0xfb, 0x06, 0xc5, 0x89, 0x3f, 0x00, 0xaa, 0x7b, + 0x7a, 0x7e, 0xed, 0x0f, 0xef, 0x0f, 0x0b, 0x27, 0xa1, 0x74, 0xd2, 0xf4, 0x53, 0xbf, 0xcf, 0xa7, + 0xfb, 0xf5, 0x9b, 0xee, 0xf7, 0xd9, 0x1e, 0xb8, 0xe9, 0x11, 0xb7, 0xd5, 0xac, 0xf9, 0x78, 0xc3, + 0x62, 0x3e, 0xd9, 0x10, 0x3e, 0x76, 0x39, 0xb6, 0x04, 0x65, 0xee, 0x46, 0xfb, 0x06, 0x76, 0xbc, + 0x06, 0xbe, 0x91, 0x34, 0x96, 0x3c, 0x9f, 0x09, 0x86, 0x8a, 0xa1, 0x57, 0x49, 0x7a, 0x95, 0x92, + 0x1d, 0x42, 0xaf, 0xcb, 0xeb, 0x69, 0x64, 0xcc, 0x39, 0x11, 0x31, 0xa6, 0x6a, 0x06, 0x68, 0x97, + 0x4b, 0xe9, 0x9e, 0x16, 0x6b, 0x7a, 0xcc, 0x25, 0xae, 0xd8, 0xb0, 0xc9, 0x49, 0xec, 0x61, 0x93, + 0x93, 0x61, 0xfd, 0xeb, 0x84, 0xc4, 0xfd, 0xeb, 0x84, 0xe8, 0xfe, 0xef, 0x0e, 0xea, 0x7f, 0xc4, + 0xda, 0xc4, 0x77, 0xb1, 0x6b, 0x25, 0xdc, 0x62, 0xdb, 0x30, 0x36, 0x5a, 0xb3, 0x62, 0x37, 0x5a, + 0xb3, 0x86, 0xf5, 0xe7, 0x56, 0x62, 0xfe, 0xdc, 0x0a, 0x67, 0xbf, 0x3d, 0xb0, 0x7f, 0x83, 0x12, + 0xc7, 0x26, 0xb6, 0xe9, 0x31, 0xe6, 0x24, 0x3c, 0x93, 0x66, 0x8d, 0xb1, 0x39, 0x10, 0x43, 0xe0, + 0xa7, 0x89, 0xc9, 0xa9, 0xa6, 0xf6, 0xb9, 0x9a, 0xf6, 0x79, 0x4a, 0x3a, 0x3c, 0xee, 0x28, 0x5b, + 0xba, 0xdf, 0xf5, 0xae, 0x0c, 0x39, 0x69, 0x60, 0xde, 0x48, 0x24, 0x87, 0x6a, 0xeb, 0xbe, 0x6f, + 0xc7, 0x7d, 0xfd, 0x8e, 0x27, 0xd8, 0x86, 0x4d, 0x2c, 0x5c, 0xdf, 0xba, 0x75, 0xcb, 0xac, 0x37, + 0xed, 0xe4, 0x52, 0xc6, 0x56, 0xed, 0x59, 0x1e, 0xe8, 0xe9, 0xdb, 0x1c, 0xf7, 0x71, 0x95, 0xe6, + 0xde, 0x99, 0x04, 0xbe, 0x22, 0x19, 0x69, 0x11, 0x46, 0xba, 0xf8, 0xaf, 0x2c, 0xe4, 0x0e, 0xe2, + 0x54, 0x45, 0x1f, 0xc2, 0x4c, 0x8d, 0xd9, 0x9d, 0x42, 0xf6, 0x4a, 0x76, 0x3d, 0xb7, 0xb9, 0x55, + 0x1a, 0x9e, 0xd4, 0xa5, 0x84, 0xfb, 0x36, 0xb3, 0x3b, 0x86, 0x02, 0x40, 0x4f, 0x20, 0x57, 0xa3, + 0xae, 0x4d, 0xdd, 0x23, 0x93, 0xd3, 0xa3, 0xc2, 0x94, 0xc2, 0x7b, 0x3b, 0x81, 0xa7, 0x86, 0x55, + 0x4a, 0x8f, 0x3d, 0xc2, 0xdc, 0x0e, 0x5c, 0xf7, 0xe9, 0x91, 0x8b, 0x45, 0xcb, 0x27, 0x06, 0xd4, + 0x22, 0x0b, 0xba, 0x03, 0xb3, 0xd8, 0xb5, 0x1a, 0xcc, 0x2f, 0x4c, 0x2b, 0xd4, 0xf5, 0x1e, 0x54, + 0x39, 0xbf, 0x08, 0x6b, 0x8f, 0xf8, 0x4f, 0x1d, 0x62, 0x30, 0x26, 0x0c, 0xed, 0x57, 0xfc, 0xc7, + 0x14, 0x5c, 0xe8, 0x1a, 0x36, 0xda, 0x85, 0xf3, 0x41, 0x8b, 0x17, 0xb2, 0x57, 0xa6, 0xd7, 0x73, + 0x9b, 0xd7, 0x47, 0x99, 0xfc, 0x5d, 0xd5, 0x36, 0x42, 0x57, 0xe4, 0xc1, 0xa5, 0x44, 0x3f, 0xd3, + 0xc3, 0x3e, 0x6e, 0x12, 0x41, 0x7c, 0xae, 0x23, 0xf0, 0xce, 0x98, 0x11, 0xad, 0x46, 0x00, 0xc6, + 0xaa, 0xe8, 0x67, 0x46, 0x3f, 0x82, 0x45, 0x9b, 0x08, 0x12, 0xf0, 0xd9, 0x58, 0xe0, 0xc2, 0x8c, + 0x62, 0xba, 0x31, 0x0a, 0xd3, 0x6e, 0xe8, 0xb9, 0x8b, 0x05, 0x36, 0xf2, 0x76, 0xb2, 0x89, 0x3e, + 0x80, 0x99, 0x26, 0x69, 0xb2, 0xc2, 0x39, 0x85, 0xb7, 0x39, 0x0a, 0xde, 0x1e, 0x69, 0xb2, 0x1d, + 0xea, 0x35, 0x88, 0x2f, 0xc8, 0x89, 0x30, 0x94, 0x7f, 0xf1, 0x57, 0x59, 0x58, 0xed, 0x3b, 0x25, + 0xf4, 0x0d, 0xc8, 0x93, 0x13, 0x8f, 0xfa, 0x1d, 0xb3, 0x41, 0xe8, 0x51, 0x43, 0xa8, 0xb4, 0x9b, + 0x31, 0x16, 0x02, 0x63, 0x45, 0xd9, 0xd0, 0xff, 0xc1, 0x9c, 0xd5, 0xc0, 0xd4, 0x35, 0xa9, 0xad, + 0x82, 0x38, 0x6f, 0x9c, 0x57, 0xed, 0x7b, 0x36, 0xba, 0x0d, 0xd3, 0x75, 0x42, 0x74, 0x1a, 0x5c, + 0xeb, 0x1a, 0x60, 0xf4, 0xc6, 0x97, 0xe4, 0xb6, 0x17, 0x0d, 0xf1, 0x03, 0x42, 0x0c, 0xe9, 0x55, + 0x7c, 0x02, 0xf9, 0xd4, 0xf4, 0x51, 0x05, 0xe6, 0xeb, 0x4d, 0xdb, 0xb4, 0x9c, 0x16, 0xe1, 0x85, + 0x19, 0x95, 0x03, 0x6f, 0x0c, 0x4e, 0x58, 0xf9, 0x9e, 0x46, 0xa0, 0x3b, 0x4e, 0x8b, 0x18, 0x73, + 0xf5, 0xa6, 0x2d, 0x1f, 0x78, 0xf1, 0xd7, 0xcb, 0x30, 0x1b, 0x64, 0x06, 0xda, 0x83, 0x73, 0xdc, + 0x23, 0xae, 0xad, 0xdf, 0xa8, 0xb7, 0x06, 0x0e, 0x32, 0xbd, 0x87, 0x45, 0xc8, 0xfb, 0xd2, 0xb9, + 0x92, 0x31, 0x02, 0x14, 0x54, 0x85, 0x59, 0xd6, 0x12, 0x5e, 0x4b, 0xe8, 0x7c, 0xfa, 0xee, 0xb8, + 0x78, 0x0f, 0x95, 0x77, 0x25, 0x63, 0x68, 0x1c, 0x74, 0x07, 0x66, 0xf8, 0x31, 0xf6, 0x74, 0x10, + 0xaf, 0x0f, 0xc4, 0x93, 0x67, 0x4d, 0x3c, 0xaa, 0x63, 0xec, 0x55, 0x32, 0x86, 0xf2, 0x44, 0x55, + 0x00, 0xf9, 0xd7, 0xb4, 0x1c, 0x4c, 0x9b, 0x3a, 0xfb, 0x36, 0x46, 0xc7, 0xd9, 0x91, 0x6e, 0x95, + 0x8c, 0x31, 0xcf, 0xc3, 0x06, 0xf2, 0x60, 0xa5, 0x8d, 0x1d, 0x6a, 0x63, 0xc1, 0x7c, 0xd3, 0x26, + 0x75, 0xea, 0x52, 0x19, 0xcc, 0xc2, 0x92, 0xc2, 0xbe, 0x3d, 0x78, 0xce, 0x6a, 0x2f, 0x8f, 0xd0, + 0x1f, 0x85, 0x18, 0xbb, 0x11, 0x44, 0x25, 0x63, 0x5c, 0x6c, 0xf7, 0x9a, 0xd1, 0xc7, 0xb0, 0x44, + 0x6b, 0x96, 0xe9, 0x13, 0x07, 0x77, 0xcc, 0x20, 0x4f, 0x0b, 0xcb, 0x8a, 0xad, 0x34, 0x90, 0x4d, + 0x9e, 0x6f, 0x11, 0xd7, 0xbd, 0x9a, 0x65, 0x48, 0xe7, 0x4a, 0xc6, 0x58, 0xa4, 0xfa, 0x59, 0xa7, + 0x40, 0x1d, 0x2e, 0x78, 0x3e, 0xf3, 0x18, 0xc7, 0x8e, 0xc9, 0x5b, 0xb5, 0x26, 0x15, 0x05, 0x34, + 0x64, 0x22, 0x89, 0x13, 0x37, 0x62, 0xa8, 0x6a, 0x8c, 0x7d, 0x05, 0x21, 0x79, 0xbc, 0x94, 0x05, + 0x39, 0xb0, 0x1c, 0xf1, 0x1c, 0x53, 0xd1, 0xb0, 0x7d, 0x7c, 0x5c, 0xb8, 0xa8, 0x98, 0xde, 0x9b, + 0x88, 0xe9, 0xb1, 0x06, 0xa9, 0x64, 0x8c, 0x25, 0xaf, 0xcb, 0x86, 0x2c, 0x58, 0x8c, 0xd7, 0xa8, + 0xcd, 0x04, 0x29, 0xac, 0x28, 0xaa, 0xf2, 0x58, 0x54, 0xd1, 0x12, 0x3d, 0x62, 0x82, 0x54, 0x32, + 0x46, 0xbe, 0x9d, 0x34, 0x48, 0x12, 0x9b, 0x38, 0xe4, 0x28, 0x26, 0x59, 0x9d, 0x80, 0x64, 0x37, + 0x84, 0x08, 0x49, 0xec, 0xa4, 0x01, 0x75, 0xe0, 0x52, 0x14, 0x37, 0x9b, 0x78, 0x8c, 0x53, 0xa1, + 0x73, 0xf9, 0x92, 0x22, 0xbb, 0x3b, 0x51, 0xf0, 0x76, 0x03, 0xa4, 0x30, 0xbb, 0x57, 0xbc, 0x3e, + 0x76, 0xf4, 0x04, 0xf2, 0xaa, 0x25, 0xf7, 0x6e, 0xe6, 0x11, 0xb7, 0xb0, 0xd6, 0x77, 0xaf, 0x1d, + 0xf0, 0xf6, 0x54, 0xb5, 0xeb, 0x43, 0x8f, 0xc8, 0xc4, 0x5e, 0xf0, 0x12, 0x6d, 0x74, 0x08, 0x8b, + 0x11, 0xb4, 0xe5, 0x30, 0x4e, 0x0a, 0xff, 0xdf, 0xf7, 0x4c, 0x1f, 0x82, 0xbd, 0x23, 0x5d, 0x65, + 0xcc, 0xbc, 0xa4, 0x01, 0x11, 0x58, 0x8e, 0xd0, 0xa3, 0x5c, 0xbb, 0x32, 0x64, 0x4b, 0xea, 0x4b, + 0x90, 0x4a, 0xb2, 0x2e, 0x1b, 0x62, 0xb0, 0x1a, 0xd1, 0xf8, 0xe4, 0x18, 0xfb, 0xb6, 0x5e, 0x99, + 0x62, 0xdf, 0xd3, 0x74, 0x08, 0x95, 0xa1, 0x10, 0xc2, 0x15, 0xb9, 0xe8, 0xf5, 0x9a, 0xd1, 0x03, + 0x98, 0xd3, 0xc9, 0x41, 0x0a, 0xeb, 0x8a, 0xe3, 0xcd, 0x51, 0x77, 0x1b, 0x9d, 0x65, 0x32, 0x58, + 0x11, 0x06, 0x3a, 0x00, 0x68, 0xb9, 0x11, 0xe2, 0xb5, 0x21, 0xab, 0xdb, 0x85, 0xf8, 0xc3, 0xc8, + 0xb3, 0x92, 0x31, 0x12, 0x38, 0xc8, 0x86, 0xa5, 0xb8, 0xa5, 0x23, 0x72, 0x5d, 0x61, 0xdf, 0x1a, + 0x1f, 0x3b, 0x8c, 0xc7, 0x85, 0x56, 0xda, 0x84, 0x38, 0xac, 0x58, 0xac, 0xd9, 0x6c, 0xb9, 0x54, + 0x74, 0xd4, 0x29, 0x62, 0x06, 0x27, 0xd9, 0xa6, 0x62, 0xfa, 0xde, 0x58, 0x6f, 0xc5, 0x4e, 0x08, + 0x54, 0x65, 0xcc, 0x09, 0xcf, 0x34, 0x64, 0xf5, 0x58, 0x51, 0x1b, 0x56, 0xbb, 0x48, 0xf5, 0x79, + 0xb7, 0xa5, 0x58, 0xef, 0x4c, 0xce, 0x1a, 0x9d, 0x7c, 0x17, 0xad, 0x5e, 0xb3, 0xdc, 0x04, 0xba, + 0x78, 0xf5, 0x56, 0x50, 0xb8, 0x39, 0xc1, 0x26, 0x90, 0x22, 0xd6, 0x6f, 0xbc, 0xdc, 0x04, 0xac, + 0x3e, 0x76, 0x64, 0xc1, 0x12, 0xb5, 0xf8, 0xe6, 0x9b, 0xd1, 0x8b, 0x84, 0x9d, 0xc2, 0xe7, 0xc3, + 0xca, 0x85, 0xf4, 0xe1, 0x23, 0xdd, 0x1f, 0x47, 0xde, 0x72, 0x31, 0x69, 0xda, 0xb4, 0x3d, 0x07, + 0xb3, 0xc1, 0xb1, 0x56, 0xfc, 0xcd, 0x0c, 0x5c, 0x4a, 0x96, 0x63, 0xc4, 0xe7, 0x9e, 0xac, 0x82, + 0xda, 0x04, 0x99, 0xb0, 0xe0, 0xe1, 0x8e, 0xc3, 0xb0, 0x6d, 0x4a, 0xb5, 0xa3, 0x0b, 0xe1, 0x77, + 0x47, 0xa9, 0xfc, 0xaa, 0x81, 0xdf, 0x7d, 0xd2, 0x91, 0xa4, 0x72, 0xfe, 0x54, 0x34, 0x89, 0x2b, + 0x8c, 0x9c, 0x17, 0xfd, 0x87, 0xa3, 0x4f, 0x60, 0x49, 0xe5, 0x90, 0xe9, 0xb6, 0x1c, 0x87, 0xd6, + 0x69, 0x50, 0x18, 0x4f, 0xf7, 0x99, 0x69, 0x5f, 0x92, 0x07, 0xa1, 0x97, 0xe4, 0x78, 0xc0, 0x04, + 0x31, 0x2e, 0x28, 0xb8, 0xc8, 0xce, 0xd1, 0x63, 0x58, 0xc0, 0x76, 0x9b, 0x5a, 0xc4, 0x74, 0x99, + 0x20, 0xbc, 0x30, 0xad, 0xd0, 0x6f, 0x8e, 0x5b, 0x26, 0x29, 0xf0, 0x5c, 0x80, 0x24, 0x9f, 0x39, + 0xda, 0x83, 0x3c, 0xb6, 0x6d, 0x9f, 0x70, 0x6e, 0xb6, 0x29, 0x39, 0x0e, 0x2b, 0xc4, 0xf5, 0x2e, + 0x64, 0xa5, 0x12, 0x63, 0x79, 0x10, 0x78, 0x3c, 0xa2, 0xe4, 0xd8, 0x58, 0xc0, 0x71, 0x83, 0xa3, + 0x1d, 0x98, 0xb5, 0x89, 0xcb, 0x9a, 0xbc, 0x70, 0xae, 0xa7, 0xd2, 0x94, 0x38, 0xc1, 0x8f, 0x01, + 0x89, 0xcd, 0xc5, 0x65, 0xcd, 0x3d, 0x22, 0xb0, 0xac, 0xf0, 0x0d, 0xed, 0x8a, 0xf6, 0x61, 0x31, + 0xa9, 0x36, 0xa8, 0x5d, 0x98, 0x55, 0x69, 0xf3, 0xed, 0xee, 0x60, 0x06, 0x82, 0xb4, 0x9f, 0xc0, + 0xb8, 0x67, 0x1b, 0x79, 0x91, 0x6c, 0x16, 0x7f, 0x9f, 0x85, 0xc2, 0xa0, 0xd5, 0x44, 0x15, 0xc8, + 0x25, 0x32, 0x44, 0x17, 0xb5, 0xdf, 0x7a, 0x61, 0x0c, 0x62, 0x2c, 0x03, 0xe2, 0x5c, 0x40, 0x7b, + 0x00, 0x56, 0x84, 0xab, 0xab, 0xd9, 0xef, 0xbc, 0x58, 0xc9, 0xed, 0x0b, 0xb9, 0x37, 0xc5, 0xa9, + 0x95, 0x00, 0x28, 0xfe, 0x2e, 0x0b, 0xcb, 0x3d, 0xe9, 0x81, 0xf6, 0x60, 0x3e, 0xca, 0x34, 0x3d, + 0xd8, 0xc1, 0x95, 0x29, 0x4f, 0x72, 0x45, 0x58, 0x46, 0x8c, 0x80, 0x2a, 0x30, 0x23, 0xb3, 0x4a, + 0x8f, 0x76, 0xb2, 0xa4, 0x52, 0x08, 0xc5, 0x9f, 0xa7, 0x15, 0xa8, 0xcc, 0x09, 0x74, 0x00, 0xf3, + 0x52, 0x3a, 0xab, 0xf4, 0xd2, 0x83, 0xbd, 0x35, 0x81, 0x00, 0x57, 0xc9, 0x36, 0x57, 0xd3, 0x4f, + 0x5f, 0x6d, 0x21, 0xfe, 0xef, 0x29, 0xb8, 0xd8, 0x67, 0xf8, 0xe8, 0x23, 0x58, 0xd0, 0x39, 0x1d, + 0xbc, 0x6b, 0xc1, 0x46, 0x54, 0x1a, 0x5d, 0x91, 0xab, 0x20, 0xe4, 0xe2, 0xe0, 0xfe, 0x6f, 0x29, + 0xf3, 0x7b, 0x30, 0x2f, 0x95, 0x75, 0x90, 0x29, 0xe7, 0xfa, 0xbf, 0xf2, 0x83, 0xe4, 0x79, 0x90, + 0x1e, 0x4d, 0xfd, 0x54, 0xfc, 0xc3, 0x32, 0x40, 0x1c, 0x32, 0xf4, 0x51, 0x5a, 0xae, 0xbe, 0x33, + 0x91, 0x5c, 0x95, 0x48, 0xb1, 0x64, 0x3d, 0xe8, 0x92, 0xac, 0xe5, 0xc9, 0x24, 0xab, 0x06, 0x0d, + 0x65, 0xeb, 0x6e, 0x4a, 0xb6, 0x96, 0x46, 0x97, 0x9b, 0x1a, 0x27, 0x90, 0xae, 0x07, 0x7d, 0xa4, + 0xeb, 0xd6, 0x98, 0xd2, 0x55, 0x03, 0x9e, 0xc9, 0xd7, 0x33, 0xf9, 0xda, 0x2d, 0x5f, 0x8f, 0x06, + 0xc8, 0xd7, 0xf7, 0x27, 0x97, 0xaf, 0x3a, 0xdb, 0xce, 0x24, 0xec, 0x99, 0x84, 0x1d, 0x41, 0xc2, + 0x5e, 0x3b, 0x75, 0x09, 0x7b, 0xfd, 0x94, 0x24, 0xec, 0x99, 0xb8, 0x7c, 0x35, 0xe2, 0xb2, 0xdf, + 0x4f, 0x05, 0x6f, 0x9c, 0xfa, 0x4f, 0x05, 0xaf, 0x44, 0xc2, 0xe6, 0x21, 0x97, 0x28, 0x0a, 0x8b, + 0x9f, 0x4e, 0xc1, 0xf2, 0xdd, 0x96, 0x68, 0x30, 0x9f, 0xfe, 0x0c, 0x47, 0xa5, 0xd1, 0x0f, 0x20, + 0x47, 0xea, 0x75, 0x62, 0x09, 0x53, 0x4a, 0x1e, 0x5d, 0xc6, 0x5c, 0x1b, 0xa2, 0x87, 0xbe, 0xaf, + 0x3c, 0x2a, 0x98, 0x37, 0x0c, 0x20, 0xd1, 0x33, 0xfa, 0x31, 0xe4, 0x02, 0xb5, 0x8a, 0x5b, 0xa2, + 0x11, 0x0a, 0xd5, 0xf2, 0xa8, 0xa5, 0xb3, 0x4a, 0x39, 0x39, 0xc0, 0x44, 0xf1, 0xcc, 0x43, 0x1b, + 0x47, 0x0e, 0xac, 0xa4, 0xcf, 0x06, 0xcd, 0x32, 0xfd, 0xd2, 0x2c, 0x28, 0x75, 0x36, 0x28, 0xb6, + 0xe2, 0x1f, 0xb3, 0x90, 0x7b, 0x4c, 0x85, 0x4b, 0x38, 0x57, 0x61, 0x8a, 0x4b, 0xf7, 0xec, 0x64, + 0xa5, 0x3b, 0xfa, 0x09, 0xbc, 0xc6, 0x85, 0xca, 0xa9, 0x48, 0x84, 0x99, 0x9e, 0xcf, 0x58, 0x3d, + 0x0c, 0xd4, 0xe6, 0x58, 0x62, 0xae, 0x2a, 0x5d, 0x8d, 0x55, 0xde, 0xc7, 0xca, 0x8b, 0xff, 0x4c, + 0xab, 0xa5, 0xaa, 0x83, 0x5d, 0x54, 0xe9, 0xbe, 0xaf, 0x1b, 0x43, 0x1d, 0x48, 0x80, 0x2f, 0xf3, + 0xce, 0xee, 0x70, 0x80, 0x32, 0x78, 0x6b, 0x6c, 0x65, 0xa0, 0x66, 0xd2, 0xa5, 0x0e, 0xee, 0xa4, + 0xee, 0xed, 0x46, 0x16, 0x06, 0x0a, 0x2a, 0xb8, 0xb1, 0xfb, 0x04, 0x96, 0x7b, 0x58, 0xd0, 0x7d, + 0x00, 0xcb, 0x69, 0x11, 0xd3, 0x73, 0xb0, 0x1b, 0xfe, 0x6a, 0x31, 0x12, 0xf8, 0x8e, 0xd3, 0x22, + 0x0a, 0x7c, 0xde, 0xd2, 0x4f, 0xbc, 0xf8, 0x59, 0x24, 0x3b, 0x14, 0xf6, 0xa9, 0xc8, 0x0e, 0x89, + 0x74, 0xea, 0xb2, 0x43, 0x83, 0xbe, 0xb4, 0xec, 0xd0, 0x38, 0xa7, 0x27, 0x3b, 0x34, 0xe0, 0x99, + 0xec, 0x38, 0x93, 0x1d, 0xaf, 0x40, 0x76, 0xe8, 0x6c, 0xfb, 0xea, 0xc8, 0x8e, 0xc7, 0x00, 0x89, + 0x5a, 0xe3, 0xb5, 0x97, 0x2b, 0x35, 0x12, 0x50, 0x5f, 0x5f, 0x3d, 0x43, 0x07, 0xeb, 0x99, 0xf2, + 0x64, 0x7a, 0x46, 0x2f, 0x7a, 0xaf, 0xa6, 0xe1, 0x2f, 0xd6, 0x34, 0xef, 0x4d, 0xac, 0x69, 0x34, + 0xe3, 0xd7, 0xf8, 0x6a, 0xae, 0x31, 0xf0, 0x6a, 0xee, 0xf6, 0x84, 0xf5, 0xb6, 0x8e, 0xc9, 0xd9, + 0xf5, 0xdc, 0x97, 0xa3, 0xa0, 0x12, 0x37, 0x67, 0xbf, 0xc8, 0xc2, 0x5c, 0x58, 0xcc, 0xa0, 0xf7, + 0xe1, 0xbc, 0xbe, 0xd0, 0xd1, 0x45, 0xcb, 0x37, 0x47, 0xb9, 0x09, 0x32, 0x42, 0x27, 0xb4, 0x02, + 0xe7, 0x7c, 0x4e, 0x48, 0xf0, 0x4d, 0xd3, 0x82, 0x11, 0x34, 0xd0, 0xeb, 0xb0, 0xe8, 0xf9, 0xc4, + 0xa2, 0x5c, 0xbe, 0x5a, 0x35, 0x2a, 0xb8, 0xaa, 0x34, 0x66, 0x8c, 0x7c, 0x64, 0xdd, 0xa6, 0x82, + 0x17, 0x9b, 0x30, 0x17, 0x96, 0x6c, 0xe8, 0x21, 0xcc, 0x7b, 0x0e, 0xa6, 0xae, 0x20, 0x27, 0x42, + 0x0f, 0xe5, 0xc6, 0x18, 0x35, 0x5f, 0xe0, 0x68, 0xc4, 0x18, 0x68, 0x09, 0xa6, 0x9f, 0x92, 0x8e, + 0x1e, 0x97, 0x7c, 0x2c, 0x5e, 0x85, 0xc5, 0xf4, 0x97, 0x5d, 0x72, 0xf4, 0xd4, 0x75, 0xf5, 0xa5, + 0xca, 0x82, 0x11, 0x34, 0x8a, 0x1e, 0xe4, 0x53, 0xa8, 0xe8, 0x3e, 0x2c, 0xfa, 0x44, 0xb4, 0x7c, + 0xd7, 0x9c, 0x24, 0x56, 0xf9, 0xc0, 0x57, 0x37, 0x11, 0x82, 0x19, 0x35, 0xc7, 0xe0, 0x23, 0x30, + 0xf5, 0x5c, 0x3c, 0x81, 0xe5, 0x14, 0xa3, 0xfa, 0x11, 0xfb, 0xe1, 0x00, 0xd6, 0xd1, 0xef, 0xea, + 0x46, 0x60, 0xfe, 0xf3, 0x74, 0xb0, 0x06, 0x8a, 0xb1, 0x0a, 0xe7, 0xdb, 0x94, 0xd3, 0x9a, 0x43, + 0x34, 0xd5, 0xcd, 0x71, 0x7e, 0x8e, 0x2f, 0x3d, 0x0a, 0x7c, 0x2b, 0x19, 0x23, 0x84, 0x41, 0x7b, + 0x30, 0xcb, 0x3c, 0xfc, 0xd3, 0x56, 0x78, 0xd9, 0xb4, 0x35, 0x16, 0xe0, 0x43, 0xe5, 0xaa, 0xea, + 0x56, 0xf5, 0x74, 0xf9, 0xb3, 0x2c, 0x9c, 0xd7, 0x2c, 0xc8, 0x00, 0xb0, 0xa2, 0x95, 0xd4, 0xe3, + 0x9d, 0xe4, 0xeb, 0xbe, 0x04, 0x0a, 0xda, 0x4f, 0x26, 0xe1, 0xd4, 0xe8, 0x62, 0xa6, 0x67, 0xf1, + 0x12, 0x89, 0x78, 0xf9, 0x10, 0x66, 0x83, 0x89, 0xfc, 0x37, 0x86, 0xbc, 0x9d, 0x4b, 0x5c, 0xa2, + 0x6c, 0xff, 0x6d, 0xea, 0xf3, 0x67, 0x6b, 0xd9, 0x2f, 0x9e, 0xad, 0x65, 0xff, 0xfa, 0x6c, 0x2d, + 0xfb, 0xcb, 0xe7, 0x6b, 0x99, 0x2f, 0x9e, 0xaf, 0x65, 0xfe, 0xf2, 0x7c, 0x2d, 0x03, 0x57, 0x2d, + 0xd6, 0x1c, 0x81, 0x6a, 0x7b, 0x29, 0x29, 0x01, 0x7d, 0x26, 0x58, 0x35, 0xfb, 0x71, 0xed, 0x88, + 0x8a, 0x46, 0xab, 0x26, 0xb7, 0xa3, 0x0d, 0x8b, 0xf1, 0x26, 0xe3, 0x1b, 0xaa, 0x58, 0x26, 0xfe, + 0x46, 0x7b, 0x33, 0x7a, 0x54, 0x9f, 0x33, 0xf2, 0x8d, 0xe1, 0x9f, 0x9d, 0xdf, 0x4e, 0x18, 0x43, + 0xdb, 0x6f, 0xa7, 0xa6, 0xab, 0x3b, 0x07, 0x9f, 0x4e, 0x15, 0xab, 0xe1, 0x10, 0x77, 0xe4, 0x10, + 0x13, 0x83, 0x29, 0x3d, 0xd2, 0x5d, 0xff, 0x14, 0x77, 0x3a, 0x94, 0x9d, 0x0e, 0x13, 0x9d, 0x0e, + 0xc3, 0x4e, 0xcf, 0xa6, 0x4a, 0xc3, 0x3b, 0x1d, 0x7e, 0x58, 0xdd, 0x0e, 0x6f, 0xa3, 0xff, 0x3e, + 0xf5, 0x7a, 0xe8, 0x50, 0x2e, 0x4b, 0x8f, 0x72, 0x39, 0xe1, 0x52, 0x2e, 0x87, 0x3e, 0xb5, 0x59, + 0xf5, 0xc9, 0xf1, 0xd6, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xba, 0x81, 0x9e, 0x96, 0x60, 0x2f, + 0x00, 0x00, } -func (m *ActionPlan) GetProposalSubmit() *v1alpha14.ProposalSubmit { - if x, ok := m.GetAction().(*ActionPlan_ProposalSubmit); ok { - return x.ProposalSubmit +func (m *Transaction) 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 nil + return dAtA[:n], nil } -func (m *ActionPlan) GetProposalWithdraw() *v1alpha14.ProposalWithdraw { - if x, ok := m.GetAction().(*ActionPlan_ProposalWithdraw); ok { - return x.ProposalWithdraw - } - return nil +func (m *Transaction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionPlan) GetValidatorVote() *v1alpha14.ValidatorVote { - if x, ok := m.GetAction().(*ActionPlan_ValidatorVote); ok { - return x.ValidatorVote +func (m *Transaction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Anchor != nil { + { + size, err := m.Anchor.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - return nil -} - -func (m *ActionPlan) GetDelegatorVote() *v1alpha14.DelegatorVotePlan { - if x, ok := m.GetAction().(*ActionPlan_DelegatorVote); ok { - return x.DelegatorVote + if m.BindingSig != nil { + { + size, err := m.BindingSig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - return nil -} - -func (m *ActionPlan) GetProposalDepositClaim() *v1alpha14.ProposalDepositClaim { - if x, ok := m.GetAction().(*ActionPlan_ProposalDepositClaim); ok { - return x.ProposalDepositClaim + if m.Body != nil { + { + size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return nil + return len(dAtA) - i, nil } -func (m *ActionPlan) GetWithdrawal() *v1alpha13.Ics20Withdrawal { - if x, ok := m.GetAction().(*ActionPlan_Withdrawal); ok { - return x.Withdrawal +func (m *TransactionBody) 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 nil + return dAtA[:n], nil } -func (m *ActionPlan) GetPositionOpen() *v1alpha11.PositionOpen { - if x, ok := m.GetAction().(*ActionPlan_PositionOpen); ok { - return x.PositionOpen - } - return nil +func (m *TransactionBody) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionPlan) GetPositionClose() *v1alpha11.PositionClose { - if x, ok := m.GetAction().(*ActionPlan_PositionClose); ok { - return x.PositionClose +func (m *TransactionBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Memo != nil { + { + size, err := m.Memo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a } - return nil -} - -func (m *ActionPlan) GetPositionWithdraw() *v1alpha11.PositionWithdrawPlan { - if x, ok := m.GetAction().(*ActionPlan_PositionWithdraw); ok { - return x.PositionWithdraw + if m.DetectionData != nil { + { + size, err := m.DetectionData.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - return nil -} - -func (m *ActionPlan) GetPositionRewardClaim() *v1alpha11.PositionRewardClaimPlan { - if x, ok := m.GetAction().(*ActionPlan_PositionRewardClaim); ok { - return x.PositionRewardClaim + if m.TransactionParameters != nil { + { + size, err := m.TransactionParameters.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - return nil -} - -func (m *ActionPlan) GetDelegate() *v1alpha12.Delegate { - if x, ok := m.GetAction().(*ActionPlan_Delegate); ok { - return x.Delegate + if len(m.Actions) > 0 { + for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Actions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } - return nil + return len(dAtA) - i, nil } -func (m *ActionPlan) GetUndelegate() *v1alpha12.Undelegate { - if x, ok := m.GetAction().(*ActionPlan_Undelegate); ok { - return x.Undelegate +func (m *TransactionParameters) 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 nil + return dAtA[:n], nil } -func (m *ActionPlan) GetUndelegateClaim() *v1alpha12.UndelegateClaimPlan { - if x, ok := m.GetAction().(*ActionPlan_UndelegateClaim); ok { - return x.UndelegateClaim - } - return nil +func (m *TransactionParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionPlan) GetDaoSpend() *v1alpha14.DaoSpend { - if x, ok := m.GetAction().(*ActionPlan_DaoSpend); ok { - return x.DaoSpend +func (m *TransactionParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Fee != nil { + { + size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - return nil + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintTransaction(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0x12 + } + if m.ExpiryHeight != 0 { + i = encodeVarintTransaction(dAtA, i, uint64(m.ExpiryHeight)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil } -func (m *ActionPlan) GetDaoOutput() *v1alpha14.DaoOutput { - if x, ok := m.GetAction().(*ActionPlan_DaoOutput); ok { - return x.DaoOutput +func (m *DetectionData) 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 nil + return dAtA[:n], nil } -func (m *ActionPlan) GetDaoDeposit() *v1alpha14.DaoDeposit { - if x, ok := m.GetAction().(*ActionPlan_DaoDeposit); ok { - return x.DaoDeposit - } - return nil +func (m *DetectionData) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*ActionPlan) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*ActionPlan_Spend)(nil), - (*ActionPlan_Output)(nil), - (*ActionPlan_Swap)(nil), - (*ActionPlan_SwapClaim)(nil), - (*ActionPlan_ValidatorDefinition)(nil), - (*ActionPlan_IbcAction)(nil), - (*ActionPlan_ProposalSubmit)(nil), - (*ActionPlan_ProposalWithdraw)(nil), - (*ActionPlan_ValidatorVote)(nil), - (*ActionPlan_DelegatorVote)(nil), - (*ActionPlan_ProposalDepositClaim)(nil), - (*ActionPlan_Withdrawal)(nil), - (*ActionPlan_PositionOpen)(nil), - (*ActionPlan_PositionClose)(nil), - (*ActionPlan_PositionWithdraw)(nil), - (*ActionPlan_PositionRewardClaim)(nil), - (*ActionPlan_Delegate)(nil), - (*ActionPlan_Undelegate)(nil), - (*ActionPlan_UndelegateClaim)(nil), - (*ActionPlan_DaoSpend)(nil), - (*ActionPlan_DaoOutput)(nil), - (*ActionPlan_DaoDeposit)(nil), +func (m *DetectionData) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.FmdClues) > 0 { + for iNdEx := len(m.FmdClues) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.FmdClues[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } + return len(dAtA) - i, nil } -// Describes a plan for forming a `Clue`. -type CluePlan struct { - // The address. - Address *v1alpha1.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - // The random seed to use for the clue plan. - Rseed []byte `protobuf:"bytes,2,opt,name=rseed,proto3" json:"rseed,omitempty"` - // The bits of precision. - PrecisionBits uint64 `protobuf:"varint,3,opt,name=precision_bits,json=precisionBits,proto3" json:"precision_bits,omitempty"` +func (m *Action) 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 *CluePlan) Reset() { *m = CluePlan{} } -func (m *CluePlan) String() string { return proto.CompactTextString(m) } -func (*CluePlan) ProtoMessage() {} -func (*CluePlan) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{26} -} -func (m *CluePlan) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) +func (m *Action) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CluePlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_CluePlan.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err + +func (m *Action) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Action != nil { + { + size := m.Action.Size() + i -= size + if _, err := m.Action.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } } - return b[:n], nil } + return len(dAtA) - i, nil } -func (m *CluePlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_CluePlan.Merge(m, src) -} -func (m *CluePlan) XXX_Size() int { - return m.Size() -} -func (m *CluePlan) XXX_DiscardUnknown() { - xxx_messageInfo_CluePlan.DiscardUnknown(m) -} - -var xxx_messageInfo_CluePlan proto.InternalMessageInfo -func (m *CluePlan) GetAddress() *v1alpha1.Address { - if m != nil { - return m.Address - } - return nil +func (m *Action_Spend) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CluePlan) GetRseed() []byte { - if m != nil { - return m.Rseed +func (m *Action_Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Spend != nil { + { + size, err := m.Spend.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return nil + return len(dAtA) - i, nil +} +func (m *Action_Output) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CluePlan) GetPrecisionBits() uint64 { - if m != nil { - return m.PrecisionBits +func (m *Action_Output) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Output != nil { + { + size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - return 0 + return len(dAtA) - i, nil } - -// Describes a plan for forming a `Memo`. -type MemoPlan struct { - // The plaintext. - Plaintext *MemoPlaintext `protobuf:"bytes,1,opt,name=plaintext,proto3" json:"plaintext,omitempty"` - // The key to use to encrypt the memo. - Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` +func (m *Action_Swap) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoPlan) Reset() { *m = MemoPlan{} } -func (m *MemoPlan) String() string { return proto.CompactTextString(m) } -func (*MemoPlan) ProtoMessage() {} -func (*MemoPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{27} -} -func (m *MemoPlan) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MemoPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MemoPlan.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err +func (m *Action_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Swap != nil { + { + size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - return b[:n], nil + i-- + dAtA[i] = 0x1a } + return len(dAtA) - i, nil } -func (m *MemoPlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemoPlan.Merge(m, src) +func (m *Action_SwapClaim) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoPlan) XXX_Size() int { - return m.Size() + +func (m *Action_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.SwapClaim != nil { + { + size, err := m.SwapClaim.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil } -func (m *MemoPlan) XXX_DiscardUnknown() { - xxx_messageInfo_MemoPlan.DiscardUnknown(m) +func (m *Action_ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -var xxx_messageInfo_MemoPlan proto.InternalMessageInfo - -func (m *MemoPlan) GetPlaintext() *MemoPlaintext { - if m != nil { - return m.Plaintext +func (m *Action_ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ValidatorDefinition != nil { + { + size, err := m.ValidatorDefinition.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 } - return nil + return len(dAtA) - i, nil +} +func (m *Action_IbcRelayAction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoPlan) GetKey() []byte { - if m != nil { - return m.Key +func (m *Action_IbcRelayAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.IbcRelayAction != nil { + { + size, err := m.IbcRelayAction.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a } - return nil + return len(dAtA) - i, nil } - -type MemoCiphertext struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +func (m *Action_ProposalSubmit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoCiphertext) Reset() { *m = MemoCiphertext{} } -func (m *MemoCiphertext) String() string { return proto.CompactTextString(m) } -func (*MemoCiphertext) ProtoMessage() {} -func (*MemoCiphertext) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{28} -} -func (m *MemoCiphertext) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MemoCiphertext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MemoCiphertext.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err +func (m *Action_ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ProposalSubmit != nil { + { + size, err := m.ProposalSubmit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - return b[:n], nil + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 } + return len(dAtA) - i, nil } -func (m *MemoCiphertext) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemoCiphertext.Merge(m, src) -} -func (m *MemoCiphertext) XXX_Size() int { - return m.Size() -} -func (m *MemoCiphertext) XXX_DiscardUnknown() { - xxx_messageInfo_MemoCiphertext.DiscardUnknown(m) +func (m *Action_ProposalWithdraw) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -var xxx_messageInfo_MemoCiphertext proto.InternalMessageInfo - -func (m *MemoCiphertext) GetInner() []byte { - if m != nil { - return m.Inner +func (m *Action_ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ProposalWithdraw != nil { + { + size, err := m.ProposalWithdraw.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a } - return nil + return len(dAtA) - i, nil } - -type MemoPlaintext struct { - Sender *v1alpha1.Address `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` - Text string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"` +func (m *Action_ValidatorVote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoPlaintext) Reset() { *m = MemoPlaintext{} } -func (m *MemoPlaintext) String() string { return proto.CompactTextString(m) } -func (*MemoPlaintext) ProtoMessage() {} -func (*MemoPlaintext) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{29} -} -func (m *MemoPlaintext) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MemoPlaintext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MemoPlaintext.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err +func (m *Action_ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ValidatorVote != nil { + { + size, err := m.ValidatorVote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - return b[:n], nil + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 } + return len(dAtA) - i, nil } -func (m *MemoPlaintext) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemoPlaintext.Merge(m, src) -} -func (m *MemoPlaintext) XXX_Size() int { - return m.Size() -} -func (m *MemoPlaintext) XXX_DiscardUnknown() { - xxx_messageInfo_MemoPlaintext.DiscardUnknown(m) +func (m *Action_DelegatorVote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -var xxx_messageInfo_MemoPlaintext proto.InternalMessageInfo - -func (m *MemoPlaintext) GetSender() *v1alpha1.Address { - if m != nil { - return m.Sender +func (m *Action_DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.DelegatorVote != nil { + { + size, err := m.DelegatorVote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa } - return nil + return len(dAtA) - i, nil +} +func (m *Action_ProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoPlaintext) GetText() string { - if m != nil { - return m.Text +func (m *Action_ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ProposalDepositClaim != nil { + { + size, err := m.ProposalDepositClaim.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb2 } - return "" + return len(dAtA) - i, nil } - -type MemoView struct { - // Types that are valid to be assigned to MemoView: - // - // *MemoView_Visible_ - // *MemoView_Opaque_ - MemoView isMemoView_MemoView `protobuf_oneof:"memo_view"` +func (m *Action_PositionOpen) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoView) Reset() { *m = MemoView{} } -func (m *MemoView) String() string { return proto.CompactTextString(m) } -func (*MemoView) ProtoMessage() {} -func (*MemoView) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{30} -} -func (m *MemoView) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MemoView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MemoView.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err +func (m *Action_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.PositionOpen != nil { + { + size, err := m.PositionOpen.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - return b[:n], nil + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xf2 } + return len(dAtA) - i, nil } -func (m *MemoView) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemoView.Merge(m, src) -} -func (m *MemoView) XXX_Size() int { - return m.Size() -} -func (m *MemoView) XXX_DiscardUnknown() { - xxx_messageInfo_MemoView.DiscardUnknown(m) +func (m *Action_PositionClose) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -var xxx_messageInfo_MemoView proto.InternalMessageInfo - -type isMemoView_MemoView interface { - isMemoView_MemoView() - MarshalTo([]byte) (int, error) - Size() int +func (m *Action_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.PositionClose != nil { + { + size, err := m.PositionClose.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xfa + } + return len(dAtA) - i, nil +} +func (m *Action_PositionWithdraw) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -type MemoView_Visible_ struct { - Visible *MemoView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"` +func (m *Action_PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.PositionWithdraw != nil { + { + size, err := m.PositionWithdraw.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil } -type MemoView_Opaque_ struct { - Opaque *MemoView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"` +func (m *Action_PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (*MemoView_Visible_) isMemoView_MemoView() {} -func (*MemoView_Opaque_) isMemoView_MemoView() {} - -func (m *MemoView) GetMemoView() isMemoView_MemoView { - if m != nil { - return m.MemoView - } - return nil -} - -func (m *MemoView) GetVisible() *MemoView_Visible { - if x, ok := m.GetMemoView().(*MemoView_Visible_); ok { - return x.Visible +func (m *Action_PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.PositionRewardClaim != nil { + { + size, err := m.PositionRewardClaim.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x92 } - return nil + return len(dAtA) - i, nil } - -func (m *MemoView) GetOpaque() *MemoView_Opaque { - if x, ok := m.GetMemoView().(*MemoView_Opaque_); ok { - return x.Opaque - } - return nil +func (m *Action_Delegate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*MemoView) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*MemoView_Visible_)(nil), - (*MemoView_Opaque_)(nil), +func (m *Action_Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Delegate != nil { + { + size, err := m.Delegate.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xc2 } + return len(dAtA) - i, nil } - -type MemoView_Visible struct { - Ciphertext *MemoCiphertext `protobuf:"bytes,1,opt,name=ciphertext,proto3" json:"ciphertext,omitempty"` - Plaintext *MemoPlaintext `protobuf:"bytes,2,opt,name=plaintext,proto3" json:"plaintext,omitempty"` +func (m *Action_Undelegate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoView_Visible) Reset() { *m = MemoView_Visible{} } -func (m *MemoView_Visible) String() string { return proto.CompactTextString(m) } -func (*MemoView_Visible) ProtoMessage() {} -func (*MemoView_Visible) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{30, 0} -} -func (m *MemoView_Visible) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MemoView_Visible) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MemoView_Visible.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err +func (m *Action_Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Undelegate != nil { + { + size, err := m.Undelegate.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - return b[:n], nil + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xca } + return len(dAtA) - i, nil } -func (m *MemoView_Visible) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemoView_Visible.Merge(m, src) -} -func (m *MemoView_Visible) XXX_Size() int { - return m.Size() -} -func (m *MemoView_Visible) XXX_DiscardUnknown() { - xxx_messageInfo_MemoView_Visible.DiscardUnknown(m) +func (m *Action_UndelegateClaim) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -var xxx_messageInfo_MemoView_Visible proto.InternalMessageInfo - -func (m *MemoView_Visible) GetCiphertext() *MemoCiphertext { - if m != nil { - return m.Ciphertext +func (m *Action_UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.UndelegateClaim != nil { + { + size, err := m.UndelegateClaim.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xd2 } - return nil + return len(dAtA) - i, nil +} +func (m *Action_CommunityPoolSpend) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoView_Visible) GetPlaintext() *MemoPlaintext { - if m != nil { - return m.Plaintext +func (m *Action_CommunityPoolSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.CommunityPoolSpend != nil { + { + size, err := m.CommunityPoolSpend.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x92 } - return nil + return len(dAtA) - i, nil } - -type MemoView_Opaque struct { - Ciphertext *MemoCiphertext `protobuf:"bytes,1,opt,name=ciphertext,proto3" json:"ciphertext,omitempty"` +func (m *Action_CommunityPoolOutput) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoView_Opaque) Reset() { *m = MemoView_Opaque{} } -func (m *MemoView_Opaque) String() string { return proto.CompactTextString(m) } -func (*MemoView_Opaque) ProtoMessage() {} -func (*MemoView_Opaque) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{30, 1} -} -func (m *MemoView_Opaque) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MemoView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MemoView_Opaque.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err +func (m *Action_CommunityPoolOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.CommunityPoolOutput != nil { + { + size, err := m.CommunityPoolOutput.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - return b[:n], nil + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x9a } + return len(dAtA) - i, nil } -func (m *MemoView_Opaque) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemoView_Opaque.Merge(m, src) -} -func (m *MemoView_Opaque) XXX_Size() int { - return m.Size() -} -func (m *MemoView_Opaque) XXX_DiscardUnknown() { - xxx_messageInfo_MemoView_Opaque.DiscardUnknown(m) +func (m *Action_CommunityPoolDeposit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -var xxx_messageInfo_MemoView_Opaque proto.InternalMessageInfo - -func (m *MemoView_Opaque) GetCiphertext() *MemoCiphertext { - if m != nil { - return m.Ciphertext +func (m *Action_CommunityPoolDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.CommunityPoolDeposit != nil { + { + size, err := m.CommunityPoolDeposit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xa2 } - return nil + return len(dAtA) - i, nil } - -type SpendPlan struct { - // The plaintext note we plan to spend. - Note *v1alpha1.Note `protobuf:"bytes,1,opt,name=note,proto3" json:"note,omitempty"` - // The position of the note we plan to spend. - Position uint64 `protobuf:"varint,2,opt,name=position,proto3" json:"position,omitempty"` - // The randomizer to use for the spend. - Randomizer []byte `protobuf:"bytes,3,opt,name=randomizer,proto3" json:"randomizer,omitempty"` - // The blinding factor to use for the value commitment. - ValueBlinding []byte `protobuf:"bytes,4,opt,name=value_blinding,json=valueBlinding,proto3" json:"value_blinding,omitempty"` - // The first blinding factor to use for the ZK spend proof. - ProofBlindingR []byte `protobuf:"bytes,5,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` - // The second blinding factor to use for the ZK spend proof. - ProofBlindingS []byte `protobuf:"bytes,6,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` -} - -func (m *SpendPlan) Reset() { *m = SpendPlan{} } -func (m *SpendPlan) String() string { return proto.CompactTextString(m) } -func (*SpendPlan) ProtoMessage() {} -func (*SpendPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{31} -} -func (m *SpendPlan) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) +func (m *Action_Ics20Withdrawal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SpendPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SpendPlan.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err + +func (m *Action_Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Ics20Withdrawal != nil { + { + size, err := m.Ics20Withdrawal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - return b[:n], nil + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xc2 } + return len(dAtA) - i, nil } -func (m *SpendPlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpendPlan.Merge(m, src) -} -func (m *SpendPlan) XXX_Size() int { - return m.Size() -} -func (m *SpendPlan) XXX_DiscardUnknown() { - xxx_messageInfo_SpendPlan.DiscardUnknown(m) +func (m *TransactionPerspective) 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 } -var xxx_messageInfo_SpendPlan proto.InternalMessageInfo +func (m *TransactionPerspective) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} -func (m *SpendPlan) GetNote() *v1alpha1.Note { - if m != nil { - return m.Note - } - return nil -} - -func (m *SpendPlan) GetPosition() uint64 { - if m != nil { - return m.Position - } - return 0 -} - -func (m *SpendPlan) GetRandomizer() []byte { - if m != nil { - return m.Randomizer - } - return nil -} - -func (m *SpendPlan) GetValueBlinding() []byte { - if m != nil { - return m.ValueBlinding - } - return nil -} - -func (m *SpendPlan) GetProofBlindingR() []byte { - if m != nil { - return m.ProofBlindingR - } - return nil -} - -func (m *SpendPlan) GetProofBlindingS() []byte { - if m != nil { - return m.ProofBlindingS - } - return nil -} - -type OutputPlan struct { - // The value to send to this output. - Value *v1alpha1.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` - // The destination address to send it to. - DestAddress *v1alpha1.Address `protobuf:"bytes,2,opt,name=dest_address,json=destAddress,proto3" json:"dest_address,omitempty"` - // The rseed to use for the new note. - Rseed []byte `protobuf:"bytes,3,opt,name=rseed,proto3" json:"rseed,omitempty"` - // The blinding factor to use for the value commitment. - ValueBlinding []byte `protobuf:"bytes,4,opt,name=value_blinding,json=valueBlinding,proto3" json:"value_blinding,omitempty"` - // The first blinding factor to use for the ZK output proof. - ProofBlindingR []byte `protobuf:"bytes,5,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"` - // The second blinding factor to use for the ZK output proof. - ProofBlindingS []byte `protobuf:"bytes,6,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"` -} - -func (m *OutputPlan) Reset() { *m = OutputPlan{} } -func (m *OutputPlan) String() string { return proto.CompactTextString(m) } -func (*OutputPlan) ProtoMessage() {} -func (*OutputPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_cd20ea79758052c4, []int{32} -} -func (m *OutputPlan) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *OutputPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_OutputPlan.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err +func (m *TransactionPerspective) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TransactionId != nil { + { + size, err := m.TransactionId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - return b[:n], nil - } -} -func (m *OutputPlan) XXX_Merge(src proto.Message) { - xxx_messageInfo_OutputPlan.Merge(m, src) -} -func (m *OutputPlan) XXX_Size() int { - return m.Size() -} -func (m *OutputPlan) XXX_DiscardUnknown() { - xxx_messageInfo_OutputPlan.DiscardUnknown(m) -} - -var xxx_messageInfo_OutputPlan proto.InternalMessageInfo - -func (m *OutputPlan) GetValue() *v1alpha1.Value { - if m != nil { - return m.Value + i-- + dAtA[i] = 0x32 } - return nil -} - -func (m *OutputPlan) GetDestAddress() *v1alpha1.Address { - if m != nil { - return m.DestAddress + if len(m.Denoms) > 0 { + for iNdEx := len(m.Denoms) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Denoms[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } } - return nil -} - -func (m *OutputPlan) GetRseed() []byte { - if m != nil { - return m.Rseed + if len(m.AddressViews) > 0 { + for iNdEx := len(m.AddressViews) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AddressViews[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } - return nil -} - -func (m *OutputPlan) GetValueBlinding() []byte { - if m != nil { - return m.ValueBlinding + if len(m.AdviceNotes) > 0 { + for iNdEx := len(m.AdviceNotes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AdviceNotes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - return nil -} - -func (m *OutputPlan) GetProofBlindingR() []byte { - if m != nil { - return m.ProofBlindingR + if len(m.SpendNullifiers) > 0 { + for iNdEx := len(m.SpendNullifiers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SpendNullifiers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - return nil -} - -func (m *OutputPlan) GetProofBlindingS() []byte { - if m != nil { - return m.ProofBlindingS + if len(m.PayloadKeys) > 0 { + for iNdEx := len(m.PayloadKeys) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PayloadKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } - return nil -} - -func init() { - proto.RegisterType((*Transaction)(nil), "penumbra.core.transaction.v1alpha1.Transaction") - proto.RegisterType((*Id)(nil), "penumbra.core.transaction.v1alpha1.Id") - proto.RegisterType((*EffectHash)(nil), "penumbra.core.transaction.v1alpha1.EffectHash") - proto.RegisterType((*TransactionBody)(nil), "penumbra.core.transaction.v1alpha1.TransactionBody") - proto.RegisterType((*MemoData)(nil), "penumbra.core.transaction.v1alpha1.MemoData") - proto.RegisterType((*TransactionParameters)(nil), "penumbra.core.transaction.v1alpha1.TransactionParameters") - proto.RegisterType((*DetectionData)(nil), "penumbra.core.transaction.v1alpha1.DetectionData") - proto.RegisterType((*Action)(nil), "penumbra.core.transaction.v1alpha1.Action") - proto.RegisterType((*TransactionPerspective)(nil), "penumbra.core.transaction.v1alpha1.TransactionPerspective") - proto.RegisterType((*PayloadKey)(nil), "penumbra.core.transaction.v1alpha1.PayloadKey") - proto.RegisterType((*PayloadKeyWithCommitment)(nil), "penumbra.core.transaction.v1alpha1.PayloadKeyWithCommitment") - proto.RegisterType((*NullifierWithNote)(nil), "penumbra.core.transaction.v1alpha1.NullifierWithNote") - proto.RegisterType((*TransactionView)(nil), "penumbra.core.transaction.v1alpha1.TransactionView") - proto.RegisterType((*TransactionBodyView)(nil), "penumbra.core.transaction.v1alpha1.TransactionBodyView") - proto.RegisterType((*ActionView)(nil), "penumbra.core.transaction.v1alpha1.ActionView") - proto.RegisterType((*SpendView)(nil), "penumbra.core.transaction.v1alpha1.SpendView") - proto.RegisterType((*SpendView_Visible)(nil), "penumbra.core.transaction.v1alpha1.SpendView.Visible") - proto.RegisterType((*SpendView_Opaque)(nil), "penumbra.core.transaction.v1alpha1.SpendView.Opaque") - proto.RegisterType((*DelegatorVoteView)(nil), "penumbra.core.transaction.v1alpha1.DelegatorVoteView") - proto.RegisterType((*DelegatorVoteView_Visible)(nil), "penumbra.core.transaction.v1alpha1.DelegatorVoteView.Visible") - proto.RegisterType((*DelegatorVoteView_Opaque)(nil), "penumbra.core.transaction.v1alpha1.DelegatorVoteView.Opaque") - proto.RegisterType((*OutputView)(nil), "penumbra.core.transaction.v1alpha1.OutputView") - proto.RegisterType((*OutputView_Visible)(nil), "penumbra.core.transaction.v1alpha1.OutputView.Visible") - proto.RegisterType((*OutputView_Opaque)(nil), "penumbra.core.transaction.v1alpha1.OutputView.Opaque") - proto.RegisterType((*Spend)(nil), "penumbra.core.transaction.v1alpha1.Spend") - proto.RegisterType((*SpendBody)(nil), "penumbra.core.transaction.v1alpha1.SpendBody") - proto.RegisterType((*Output)(nil), "penumbra.core.transaction.v1alpha1.Output") - proto.RegisterType((*OutputBody)(nil), "penumbra.core.transaction.v1alpha1.OutputBody") - proto.RegisterType((*AuthorizationData)(nil), "penumbra.core.transaction.v1alpha1.AuthorizationData") - proto.RegisterType((*WitnessData)(nil), "penumbra.core.transaction.v1alpha1.WitnessData") - proto.RegisterType((*TransactionPlan)(nil), "penumbra.core.transaction.v1alpha1.TransactionPlan") - proto.RegisterType((*ActionPlan)(nil), "penumbra.core.transaction.v1alpha1.ActionPlan") - proto.RegisterType((*CluePlan)(nil), "penumbra.core.transaction.v1alpha1.CluePlan") - proto.RegisterType((*MemoPlan)(nil), "penumbra.core.transaction.v1alpha1.MemoPlan") - proto.RegisterType((*MemoCiphertext)(nil), "penumbra.core.transaction.v1alpha1.MemoCiphertext") - proto.RegisterType((*MemoPlaintext)(nil), "penumbra.core.transaction.v1alpha1.MemoPlaintext") - proto.RegisterType((*MemoView)(nil), "penumbra.core.transaction.v1alpha1.MemoView") - proto.RegisterType((*MemoView_Visible)(nil), "penumbra.core.transaction.v1alpha1.MemoView.Visible") - proto.RegisterType((*MemoView_Opaque)(nil), "penumbra.core.transaction.v1alpha1.MemoView.Opaque") - proto.RegisterType((*SpendPlan)(nil), "penumbra.core.transaction.v1alpha1.SpendPlan") - proto.RegisterType((*OutputPlan)(nil), "penumbra.core.transaction.v1alpha1.OutputPlan") -} - -func init() { - proto.RegisterFile("penumbra/core/transaction/v1alpha1/transaction.proto", fileDescriptor_cd20ea79758052c4) -} - -var fileDescriptor_cd20ea79758052c4 = []byte{ - // 2795 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcf, 0x6f, 0xe3, 0xc6, - 0xf5, 0x17, 0x25, 0xdb, 0x6b, 0x3f, 0xc9, 0x5a, 0x7b, 0xf6, 0x47, 0xf4, 0x35, 0xbe, 0x70, 0x16, - 0x4c, 0xb2, 0xf5, 0x6e, 0x12, 0x39, 0xeb, 0xdd, 0x4d, 0x50, 0x27, 0x6d, 0x63, 0xd9, 0xd9, 0xc8, - 0xbb, 0xf1, 0x5a, 0xa1, 0x53, 0xbb, 0x49, 0x9d, 0xb0, 0x23, 0x72, 0x6c, 0x11, 0x96, 0x48, 0x96, - 0xa4, 0xe4, 0x75, 0xfe, 0x81, 0xa6, 0x97, 0x22, 0x05, 0x7a, 0x28, 0x7a, 0x29, 0x50, 0xe4, 0xd4, - 0x43, 0xff, 0x80, 0x16, 0x3d, 0x37, 0x68, 0x2f, 0x01, 0x7a, 0x29, 0x10, 0x14, 0x48, 0x37, 0xa7, - 0xfe, 0xb8, 0xf4, 0xdc, 0x4b, 0x31, 0x3f, 0x38, 0x24, 0x25, 0x7a, 0x45, 0xd9, 0x4e, 0x83, 0xfc, - 0x38, 0x99, 0xf3, 0xfc, 0xde, 0x67, 0x66, 0xde, 0x7b, 0x33, 0xf3, 0xde, 0x9b, 0x11, 0xdc, 0x72, - 0x89, 0xdd, 0xed, 0x34, 0x3d, 0xbc, 0x68, 0x38, 0x1e, 0x59, 0x0c, 0x3c, 0x6c, 0xfb, 0xd8, 0x08, - 0x2c, 0xc7, 0x5e, 0xec, 0xdd, 0xc0, 0x6d, 0xb7, 0x85, 0x6f, 0xc4, 0x89, 0x55, 0xd7, 0x73, 0x02, - 0x07, 0xa9, 0xa1, 0x54, 0x95, 0x4a, 0x55, 0xe3, 0x0c, 0xa1, 0xd4, 0xdc, 0xf5, 0x24, 0xb2, 0xe1, - 0x1d, 0xb9, 0x81, 0x13, 0x81, 0xf2, 0x36, 0xc7, 0x9b, 0x5b, 0x48, 0xf2, 0xfa, 0x01, 0x3e, 0x20, - 0x11, 0x2b, 0x6b, 0x0a, 0xce, 0x27, 0x93, 0x9c, 0x56, 0xd3, 0x88, 0xf8, 0xac, 0xa6, 0x91, 0xce, - 0x65, 0x92, 0x07, 0x11, 0x97, 0x49, 0x1e, 0x08, 0xae, 0xa5, 0x24, 0xd7, 0xbe, 0xd3, 0x23, 0x9e, - 0x8d, 0x6d, 0x23, 0xd6, 0x75, 0x44, 0xe3, 0x32, 0xea, 0x6f, 0x15, 0x28, 0xbe, 0x11, 0x4d, 0x17, - 0xbd, 0x0a, 0x63, 0x4d, 0xc7, 0x3c, 0xaa, 0x28, 0x57, 0x94, 0x85, 0xe2, 0xd2, 0xcd, 0xea, 0x70, - 0xc5, 0x54, 0x63, 0xe2, 0x35, 0xc7, 0x3c, 0xd2, 0x18, 0x00, 0x7a, 0x1c, 0x8a, 0x4d, 0xcb, 0x36, - 0x2d, 0x7b, 0x5f, 0xf7, 0xad, 0xfd, 0x4a, 0xfe, 0x8a, 0xb2, 0x50, 0xd2, 0x40, 0x90, 0xb6, 0xac, - 0x7d, 0xb4, 0x02, 0x13, 0xd8, 0x36, 0x5a, 0x8e, 0x57, 0x29, 0xb0, 0xbe, 0xae, 0xf5, 0xf5, 0x25, - 0x14, 0x2a, 0xbb, 0xd9, 0x20, 0xde, 0x41, 0x9b, 0x68, 0x8e, 0x13, 0x68, 0x42, 0x50, 0xad, 0x40, - 0x7e, 0xdd, 0x44, 0x08, 0xc6, 0x5a, 0xd8, 0x6f, 0xb1, 0x21, 0x97, 0x34, 0xf6, 0xad, 0xaa, 0x00, - 0xaf, 0xec, 0xed, 0x11, 0x23, 0xa8, 0x63, 0xbf, 0x85, 0x2e, 0xc2, 0xb8, 0x65, 0xdb, 0xc4, 0x13, - 0x2c, 0xbc, 0xa1, 0x7e, 0x50, 0x80, 0xf3, 0x7d, 0x63, 0x47, 0x6b, 0x70, 0x8e, 0xb7, 0xfc, 0x8a, - 0x72, 0xa5, 0xb0, 0x50, 0x5c, 0xba, 0x9e, 0x45, 0x03, 0x2b, 0xac, 0xad, 0x85, 0xa2, 0xc8, 0x85, - 0xcb, 0x31, 0x3e, 0xdd, 0xc5, 0x1e, 0xee, 0x90, 0x80, 0x78, 0x3e, 0x53, 0x43, 0x71, 0xe9, 0x9b, - 0x23, 0xaa, 0xb5, 0x21, 0x01, 0xb4, 0x4b, 0x41, 0x1a, 0x19, 0xdd, 0x82, 0xc2, 0x1e, 0x21, 0x42, - 0x93, 0xea, 0x10, 0x4d, 0xde, 0x21, 0x44, 0xa3, 0xec, 0xe8, 0x7b, 0x50, 0x36, 0x49, 0x40, 0xf8, - 0x28, 0x4d, 0x1c, 0xe0, 0xca, 0x18, 0x03, 0xb8, 0x91, 0x65, 0x7c, 0x6b, 0xa1, 0xe4, 0x1a, 0x0e, - 0xb0, 0x36, 0x6d, 0xc6, 0x9b, 0x68, 0x1d, 0xa6, 0x3a, 0xa4, 0xe3, 0x70, 0xd0, 0x71, 0x06, 0xfa, - 0x4c, 0x16, 0xd0, 0x0d, 0xd2, 0x71, 0x18, 0xde, 0x64, 0x47, 0x7c, 0xa9, 0xeb, 0x30, 0x19, 0x52, - 0xd1, 0x75, 0x28, 0x13, 0x9b, 0x4d, 0x87, 0x98, 0x3a, 0xe5, 0xe0, 0x16, 0xad, 0xe7, 0xb4, 0x69, - 0x49, 0xa7, 0xcc, 0xef, 0x29, 0x4a, 0x6d, 0x16, 0xce, 0xeb, 0x49, 0x66, 0x75, 0x07, 0x2e, 0xa5, - 0x6a, 0x15, 0x3d, 0x01, 0xd3, 0xe4, 0x81, 0x6b, 0x79, 0x47, 0x7a, 0x8b, 0x58, 0xfb, 0xad, 0x80, - 0xc1, 0x8e, 0x69, 0x25, 0x4e, 0xac, 0x33, 0x1a, 0xfa, 0x3f, 0x98, 0x34, 0x5a, 0xd8, 0xb2, 0x75, - 0xcb, 0x64, 0x76, 0x9c, 0xd2, 0xce, 0xb1, 0xf6, 0xba, 0xa9, 0xbe, 0x0e, 0xd3, 0x09, 0x75, 0xa0, - 0x97, 0x61, 0x6a, 0xaf, 0x63, 0xea, 0x46, 0xbb, 0x4b, 0xfc, 0xca, 0x18, 0xf3, 0xa4, 0x27, 0x86, - 0x58, 0x65, 0xb5, 0xdd, 0x25, 0xda, 0xe4, 0x5e, 0xc7, 0xa4, 0x1f, 0xbe, 0xfa, 0xe7, 0x32, 0x4c, - 0x70, 0xbf, 0x42, 0x2b, 0x30, 0xee, 0xbb, 0xc4, 0x36, 0xc5, 0xa2, 0xbc, 0x96, 0x45, 0x91, 0x5b, - 0x54, 0xa0, 0x9e, 0xd3, 0xb8, 0x24, 0x5a, 0x83, 0x09, 0xa7, 0x1b, 0xb8, 0xdd, 0x40, 0x78, 0x60, - 0x26, 0xb7, 0xde, 0x64, 0x12, 0xf5, 0x9c, 0x26, 0x64, 0xd1, 0xf3, 0x30, 0xe6, 0x1f, 0x62, 0x57, - 0xb8, 0xd9, 0x95, 0x3e, 0x0c, 0xba, 0x11, 0x45, 0xfd, 0x1f, 0x62, 0xb7, 0x9e, 0xd3, 0x18, 0x3f, - 0xba, 0x03, 0x40, 0xff, 0xea, 0x46, 0x1b, 0x5b, 0x1d, 0xe1, 0x63, 0x4f, 0x0d, 0x93, 0x5e, 0xa5, - 0xcc, 0xf5, 0x9c, 0x36, 0xe5, 0x87, 0x0d, 0xb4, 0x07, 0x17, 0x7b, 0xb8, 0x6d, 0x99, 0x38, 0x70, - 0x3c, 0xdd, 0x24, 0x7b, 0x96, 0x6d, 0xd1, 0x11, 0x57, 0x66, 0x52, 0xbd, 0x96, 0x6f, 0xb3, 0x12, - 0x73, 0x3b, 0x94, 0x5c, 0x93, 0x82, 0xf5, 0x9c, 0x76, 0xa1, 0x37, 0x48, 0xa6, 0xe3, 0xb5, 0x9a, - 0x86, 0xce, 0xf5, 0x51, 0x99, 0x4d, 0x1d, 0x2f, 0xdd, 0x9c, 0x25, 0xf6, 0x7a, 0xd3, 0xe0, 0xb6, - 0xa2, 0xe3, 0xb5, 0xc2, 0x06, 0xda, 0x85, 0xf3, 0xae, 0xe7, 0xb8, 0x8e, 0x8f, 0xdb, 0xba, 0xdf, - 0x6d, 0x76, 0xac, 0xa0, 0x82, 0x52, 0x87, 0x1a, 0xdb, 0x96, 0x25, 0x66, 0x43, 0x48, 0x6e, 0x31, - 0xc1, 0x7a, 0x4e, 0x2b, 0xbb, 0x09, 0x0a, 0x6a, 0xc2, 0xac, 0x44, 0x3f, 0xb4, 0x82, 0x96, 0xe9, - 0xe1, 0xc3, 0xca, 0x85, 0xd4, 0x7d, 0xfb, 0x51, 0xf8, 0x3b, 0x42, 0xb4, 0x9e, 0xd3, 0x66, 0xdc, - 0x3e, 0x1a, 0x7a, 0x13, 0xca, 0x91, 0xc6, 0x7b, 0x4e, 0x40, 0x2a, 0x17, 0x59, 0x07, 0xcf, 0x65, - 0xe8, 0x40, 0x2a, 0x7c, 0xdb, 0x09, 0x08, 0x5d, 0xa2, 0xbd, 0x38, 0x81, 0x42, 0x9b, 0xa4, 0x4d, - 0xf6, 0x23, 0xe8, 0x4b, 0x99, 0xa1, 0xd7, 0x42, 0xc1, 0x10, 0xda, 0x8c, 0x13, 0x90, 0x03, 0x97, - 0xa5, 0x66, 0x4c, 0xe2, 0x3a, 0xbe, 0x15, 0x08, 0xdf, 0xbb, 0xcc, 0xba, 0x78, 0x61, 0x04, 0xf5, - 0xac, 0x71, 0xf9, 0xd0, 0x1b, 0x2f, 0xba, 0x29, 0x74, 0xb4, 0x09, 0xd3, 0xac, 0x45, 0xf7, 0x51, - 0xc7, 0x25, 0x76, 0x65, 0x9e, 0xf5, 0xb3, 0xf0, 0x28, 0x1f, 0x6f, 0x08, 0x81, 0x4d, 0x97, 0x50, - 0xb7, 0x29, 0xb9, 0xb1, 0x36, 0xd2, 0xa0, 0x2c, 0x01, 0x8d, 0xb6, 0xe3, 0x93, 0xca, 0xe3, 0xa9, - 0x6b, 0x3f, 0x15, 0x71, 0x95, 0x0a, 0x50, 0xad, 0xb8, 0x71, 0x02, 0xfa, 0x3e, 0xcc, 0x4a, 0x4c, - 0xe9, 0x2f, 0x57, 0x52, 0xf7, 0xe6, 0x54, 0xd8, 0x84, 0xa3, 0xf4, 0xd1, 0x10, 0x81, 0x4b, 0x12, - 0xdc, 0x23, 0x87, 0xd8, 0x33, 0x85, 0xc6, 0x55, 0xd6, 0xc1, 0x62, 0x96, 0x0e, 0x34, 0x26, 0x17, - 0x6a, 0xfa, 0x82, 0x3b, 0x48, 0x46, 0x6b, 0x30, 0x29, 0x4c, 0x4d, 0x2a, 0x0b, 0x0c, 0xf9, 0xea, - 0xa3, 0x57, 0xbd, 0xf0, 0x14, 0xaa, 0x0e, 0x29, 0x89, 0xee, 0x02, 0x74, 0x6d, 0x89, 0x73, 0x2d, - 0xd5, 0x56, 0x7d, 0x38, 0xdf, 0x95, 0xfc, 0xf5, 0x9c, 0x16, 0x93, 0x46, 0x6f, 0xc1, 0x4c, 0xd4, - 0x12, 0x73, 0xbe, 0xce, 0x10, 0x9f, 0xcd, 0x8a, 0x18, 0xce, 0xf8, 0x7c, 0x37, 0x49, 0x42, 0x77, - 0x61, 0xca, 0xc4, 0x8e, 0xce, 0x37, 0xff, 0x25, 0x06, 0xfa, 0x74, 0x96, 0xd5, 0x81, 0x9d, 0x70, - 0xfb, 0x9f, 0x34, 0xc5, 0x37, 0xda, 0x00, 0xa0, 0x58, 0xe2, 0x14, 0xb8, 0x99, 0x6a, 0xf6, 0x63, - 0xc0, 0xe4, 0x39, 0x40, 0x47, 0xc3, 0x1b, 0xa8, 0x01, 0x45, 0x0a, 0x27, 0x56, 0x57, 0xe5, 0x56, - 0xea, 0x8c, 0x8f, 0xc1, 0x13, 0x4b, 0x87, 0x2a, 0xd2, 0x94, 0x2d, 0xf4, 0x26, 0xcc, 0x58, 0x86, - 0xbf, 0xf4, 0x9c, 0xf4, 0x4d, 0xdc, 0xae, 0x7c, 0xa8, 0xa4, 0x4e, 0x3a, 0xb9, 0xf7, 0x52, 0xa1, - 0x1d, 0x29, 0x43, 0xf5, 0x68, 0x25, 0x49, 0xb5, 0x49, 0x98, 0xe0, 0x7b, 0xb9, 0xfa, 0xe3, 0x31, - 0xb8, 0x1c, 0x0f, 0x01, 0x88, 0xe7, 0xbb, 0xf4, 0xd8, 0xee, 0x11, 0xa4, 0x43, 0xc9, 0xc5, 0x47, - 0x6d, 0x07, 0x9b, 0xfa, 0x01, 0x39, 0x0a, 0xe3, 0xbf, 0x97, 0xb2, 0x1c, 0x94, 0x0d, 0x2e, 0x77, - 0x8f, 0x1c, 0xd1, 0x4e, 0x57, 0x9d, 0x4e, 0xc7, 0x0a, 0x3a, 0xc4, 0x0e, 0xb4, 0xa2, 0x2b, 0xff, - 0xe3, 0xa3, 0x1f, 0xc0, 0x0c, 0xb3, 0xa4, 0x6e, 0x77, 0xdb, 0x6d, 0x6b, 0xcf, 0xe2, 0xf1, 0x20, - 0xed, 0xe4, 0x76, 0x96, 0x4e, 0xee, 0x87, 0x52, 0xb4, 0x8f, 0xfb, 0x4e, 0x40, 0xb4, 0xf3, 0x0c, - 0x4e, 0xd2, 0x7d, 0x74, 0x07, 0x4a, 0xd8, 0xec, 0x59, 0x06, 0xd1, 0x6d, 0x27, 0x20, 0x7e, 0xa5, - 0x90, 0x29, 0xf0, 0x60, 0x58, 0x45, 0x2e, 0x48, 0xbf, 0x7d, 0xba, 0x9d, 0x61, 0xd3, 0xf4, 0x88, - 0xef, 0xeb, 0x3d, 0x8b, 0x1c, 0x86, 0x11, 0xcc, 0xf5, 0x21, 0x40, 0x2b, 0x5c, 0x66, 0xdb, 0x22, - 0x87, 0x5a, 0x09, 0x47, 0x0d, 0x9f, 0x86, 0x1f, 0x26, 0xb1, 0x9d, 0x8e, 0x5f, 0x19, 0x67, 0x48, - 0xcf, 0x0c, 0x41, 0x5a, 0xa3, 0xcc, 0x1b, 0x24, 0xc0, 0x34, 0x7e, 0xd4, 0x84, 0x2c, 0xda, 0x80, - 0x72, 0x3c, 0xac, 0xb6, 0xcc, 0xca, 0x44, 0xea, 0x16, 0x90, 0xaa, 0xbe, 0x75, 0x53, 0x9b, 0x8e, - 0xfd, 0x63, 0xdd, 0xa4, 0x39, 0x42, 0x64, 0xb8, 0x63, 0x72, 0x84, 0xdf, 0x29, 0x50, 0x39, 0xce, - 0xba, 0x68, 0x13, 0x8a, 0x31, 0x8f, 0x11, 0xd1, 0x59, 0x75, 0x34, 0x87, 0xd1, 0x20, 0x72, 0x11, - 0x74, 0x1f, 0xc0, 0x90, 0xf0, 0x22, 0x52, 0xab, 0x0e, 0x51, 0xd5, 0x56, 0x40, 0xb7, 0x8b, 0xc8, - 0xe5, 0x62, 0x08, 0xea, 0xcf, 0x14, 0x98, 0x1d, 0x70, 0x1b, 0x74, 0x07, 0xa6, 0xa4, 0x07, 0x8a, - 0x41, 0x2f, 0x0c, 0x73, 0x91, 0x90, 0x5f, 0x8b, 0x44, 0xd1, 0x0b, 0x30, 0x46, 0xdd, 0x4c, 0x8c, - 0x33, 0x93, 0x97, 0x31, 0x01, 0xf5, 0x4f, 0x4a, 0x22, 0xf1, 0xa2, 0x2e, 0x82, 0xde, 0x80, 0x29, - 0x9a, 0x36, 0x32, 0x7f, 0x13, 0x83, 0x7a, 0xe1, 0x04, 0xc9, 0x27, 0xf3, 0xbd, 0xc9, 0xa6, 0xf8, - 0xfa, 0x9f, 0x24, 0xa1, 0x9f, 0x14, 0xe0, 0x42, 0xca, 0x28, 0xd0, 0xeb, 0x50, 0x12, 0x8e, 0xca, - 0xd7, 0x10, 0xdf, 0x4f, 0xaa, 0xd9, 0xf3, 0x49, 0x36, 0x97, 0x62, 0xa4, 0xa3, 0x2f, 0x4e, 0x5e, - 0xf9, 0xf6, 0x99, 0xe5, 0x95, 0x3c, 0xb6, 0x8b, 0x11, 0xde, 0x53, 0x14, 0x74, 0x5f, 0x24, 0x97, - 0xcc, 0x57, 0x46, 0x4c, 0x2e, 0xa9, 0x22, 0xeb, 0x0a, 0x4f, 0x2f, 0xe9, 0x77, 0x98, 0x29, 0x26, - 0xc7, 0x5b, 0x2b, 0x01, 0xe8, 0xb2, 0x0f, 0xf5, 0xdf, 0x65, 0x80, 0xc8, 0x26, 0xe8, 0x95, 0x64, - 0x3e, 0xf6, 0x6c, 0xe6, 0x7c, 0x8c, 0x75, 0x2e, 0x73, 0xb2, 0x7a, 0x5f, 0x4e, 0x56, 0xcd, 0x9e, - 0x93, 0x09, 0xa0, 0x30, 0x2f, 0x5b, 0x4e, 0xe4, 0x65, 0x4f, 0x0e, 0xcb, 0xac, 0x84, 0x34, 0xcf, - 0xcd, 0xee, 0xa6, 0xe4, 0x66, 0xd7, 0x32, 0xe5, 0x66, 0x02, 0xe6, 0xeb, 0xfc, 0xec, 0xcb, 0x99, - 0x9f, 0xbd, 0x73, 0x4c, 0x7e, 0x76, 0x3b, 0xdb, 0x22, 0x8e, 0xe5, 0x63, 0xc2, 0x51, 0xbe, 0x4e, - 0xd2, 0xbe, 0x82, 0x49, 0xda, 0xb5, 0x33, 0x4a, 0xd2, 0xae, 0x9f, 0x2a, 0x49, 0xfb, 0x4a, 0x25, - 0x52, 0x69, 0x19, 0xe9, 0xd3, 0x67, 0x94, 0x91, 0x7e, 0x86, 0x49, 0xda, 0x34, 0x14, 0x63, 0xf1, - 0x92, 0xfa, 0xd3, 0x02, 0x4c, 0xc9, 0x43, 0x13, 0xbd, 0x0e, 0xe7, 0x7a, 0x96, 0x6f, 0x35, 0xdb, - 0x44, 0x1c, 0xba, 0xb7, 0x47, 0x3a, 0x74, 0xab, 0xdb, 0x5c, 0xb8, 0x9e, 0xd3, 0x42, 0x1c, 0x74, - 0x1f, 0x26, 0x1c, 0x17, 0xff, 0xb0, 0x1b, 0x06, 0xb0, 0xb7, 0x46, 0x43, 0xdc, 0x64, 0xb2, 0xec, - 0x10, 0x66, 0x5f, 0x73, 0x3f, 0x52, 0xe0, 0x9c, 0xe8, 0x06, 0x7d, 0xe7, 0xa4, 0x15, 0xdb, 0x30, - 0x36, 0x78, 0x31, 0x11, 0x5b, 0x7f, 0x23, 0x43, 0x6c, 0xcd, 0xa2, 0x45, 0x26, 0x34, 0xb7, 0x0e, - 0x13, 0x7c, 0x74, 0xa7, 0x1e, 0x07, 0x8d, 0x83, 0x78, 0xce, 0xca, 0x6c, 0xf2, 0xd7, 0x02, 0xcc, - 0x0e, 0xec, 0xec, 0xe8, 0xcd, 0x7e, 0xdb, 0x7c, 0xeb, 0x44, 0x27, 0x44, 0x9a, 0x8d, 0xb6, 0xfb, - 0x6c, 0xf4, 0xd2, 0xc9, 0x90, 0x07, 0x6c, 0xf5, 0xcb, 0x98, 0xad, 0x76, 0x06, 0xce, 0x39, 0xe5, - 0x64, 0x75, 0xc8, 0xfe, 0x03, 0xee, 0x54, 0x36, 0xc4, 0xd2, 0x86, 0x9f, 0xd5, 0xf8, 0x6a, 0x33, - 0xfd, 0xc0, 0xea, 0xbf, 0x0a, 0x00, 0x51, 0x80, 0x89, 0xb4, 0x7e, 0xc3, 0x3e, 0x3f, 0x5a, 0x84, - 0x9a, 0x66, 0xd1, 0xcd, 0x3e, 0x8b, 0xde, 0x1e, 0x11, 0x72, 0xc0, 0x94, 0x1f, 0xc7, 0x4c, 0x59, - 0x93, 0x11, 0xb5, 0x32, 0xea, 0x2d, 0x87, 0x8c, 0xa5, 0x4f, 0x63, 0xb5, 0xfe, 0x8a, 0x40, 0xe1, - 0xb4, 0x15, 0x81, 0xb9, 0xd7, 0xa4, 0x1b, 0x9c, 0xc1, 0xdc, 0xe8, 0x16, 0xcb, 0xbf, 0xf8, 0x72, - 0xfe, 0x58, 0x81, 0x71, 0x7e, 0xa6, 0xad, 0x24, 0x6e, 0x7d, 0xb3, 0x27, 0x34, 0xb1, 0xfb, 0xde, - 0xd7, 0x60, 0x12, 0x77, 0x83, 0x96, 0xcc, 0xb3, 0x07, 0x83, 0xe8, 0x81, 0xca, 0x05, 0x45, 0x58, - 0xe9, 0x06, 0xad, 0x2d, 0x6b, 0xdf, 0xc6, 0x41, 0xd7, 0x23, 0xda, 0x39, 0xcc, 0x9b, 0x68, 0x05, - 0xc6, 0x5d, 0xcf, 0x71, 0xf6, 0x84, 0x0a, 0x9f, 0x1e, 0x02, 0xf5, 0xd6, 0x3d, 0x06, 0xd6, 0xa0, - 0x22, 0x1a, 0x97, 0x54, 0x7f, 0xa1, 0x88, 0x03, 0x84, 0x5d, 0xec, 0xea, 0x80, 0x9a, 0xb8, 0x4d, - 0x57, 0x87, 0x1e, 0x2b, 0xb1, 0xa4, 0xaf, 0xa4, 0x7e, 0xf4, 0x1a, 0x17, 0x8c, 0x15, 0x59, 0x66, - 0x9b, 0xfd, 0x24, 0xf4, 0xff, 0xf1, 0xaa, 0x4a, 0x81, 0x15, 0x1a, 0x62, 0xb5, 0x92, 0x32, 0xe4, - 0xbd, 0x03, 0x96, 0x5d, 0x95, 0xb4, 0xbc, 0x77, 0xa0, 0xbe, 0xaf, 0xc0, 0x84, 0x08, 0x00, 0x6a, - 0x09, 0xdd, 0x8f, 0x90, 0x04, 0xc6, 0x94, 0x5f, 0x0b, 0xd5, 0x95, 0x4f, 0x0d, 0x47, 0x06, 0xd5, - 0xc5, 0x11, 0x12, 0xfa, 0xfa, 0x49, 0x3e, 0x5c, 0xfc, 0x4c, 0x61, 0x1b, 0x50, 0xa2, 0x2e, 0xad, - 0x0b, 0x67, 0x3c, 0xc6, 0xeb, 0xd2, 0xd6, 0x83, 0x70, 0x65, 0xad, 0x68, 0x47, 0x8d, 0x63, 0xf4, - 0x9f, 0x3f, 0x3b, 0xfd, 0x2f, 0xc0, 0xcc, 0xa1, 0x87, 0x5d, 0x57, 0xdc, 0xf5, 0xca, 0xf5, 0x57, - 0xd2, 0xca, 0x82, 0x4e, 0xd3, 0xff, 0x7b, 0xe4, 0x08, 0x5d, 0x85, 0xf3, 0x4e, 0xef, 0x40, 0x0f, - 0xb9, 0x29, 0x23, 0x37, 0xcc, 0xb4, 0xd3, 0x3b, 0xd8, 0xe1, 0xd4, 0x7b, 0xe4, 0x48, 0xfd, 0x79, - 0x1e, 0x66, 0xa9, 0x7b, 0x3a, 0x9e, 0xf5, 0x2e, 0x96, 0x37, 0xbb, 0x77, 0xa1, 0x48, 0xd8, 0xcb, - 0x02, 0x5d, 0x3e, 0x3a, 0x18, 0x5e, 0x36, 0x8a, 0xde, 0x22, 0x68, 0x40, 0xa2, 0x77, 0x09, 0x1a, - 0x14, 0xf9, 0xe9, 0x4a, 0xdd, 0x3e, 0x2c, 0x06, 0x9f, 0x60, 0xd9, 0xf0, 0x33, 0x9a, 0xd2, 0x7c, - 0x64, 0xc0, 0xc5, 0xe4, 0xae, 0x2e, 0xc0, 0x0b, 0x27, 0x05, 0x47, 0x89, 0x53, 0x83, 0x75, 0xa2, - 0xfe, 0x5e, 0x81, 0xe2, 0x8e, 0x15, 0xd8, 0xc4, 0xf7, 0x99, 0x52, 0xa2, 0x32, 0x9a, 0x72, 0xc2, - 0x32, 0x1a, 0x3a, 0x80, 0xc7, 0xfc, 0x80, 0x05, 0xac, 0xd2, 0xa6, 0x3a, 0x73, 0xcc, 0x50, 0x2f, - 0x37, 0x47, 0x2b, 0x84, 0x72, 0xdf, 0xbe, 0xe4, 0xa7, 0x50, 0x7d, 0xf5, 0xef, 0xf9, 0x44, 0x05, - 0xb2, 0xd1, 0xc6, 0x36, 0xaa, 0xf7, 0x3f, 0xfd, 0x18, 0xa1, 0x54, 0x47, 0x01, 0xa2, 0xe7, 0x1f, - 0x03, 0xaf, 0x09, 0xf2, 0x43, 0x5e, 0x13, 0x14, 0x12, 0xaf, 0x09, 0xc2, 0xa2, 0xdb, 0xd8, 0x68, - 0x45, 0xb7, 0x7b, 0x00, 0x46, 0xbb, 0x4b, 0x74, 0xb7, 0x8d, 0xed, 0xe3, 0xea, 0xec, 0xa9, 0x53, - 0x58, 0x6d, 0x77, 0x09, 0x9b, 0xc0, 0x94, 0x21, 0xbe, 0x7c, 0xf9, 0x7e, 0x83, 0x82, 0x89, 0x2a, - 0x7b, 0xe6, 0x12, 0x1b, 0xc3, 0x62, 0x05, 0x36, 0xfa, 0xa5, 0xfe, 0x53, 0x16, 0xcf, 0x98, 0x9a, - 0x4f, 0x5c, 0x3c, 0xa3, 0xd2, 0x67, 0x52, 0x3c, 0x13, 0x40, 0x27, 0x2c, 0x9e, 0x09, 0xe9, 0xd3, - 0x16, 0xcf, 0x04, 0xcc, 0xd7, 0xc5, 0xb3, 0x2f, 0x67, 0xf1, 0xec, 0xed, 0x63, 0x8a, 0x67, 0xb7, - 0x46, 0x0d, 0xda, 0x85, 0x9f, 0x7c, 0xde, 0xb5, 0xb3, 0x0d, 0x80, 0x58, 0xc6, 0xff, 0xd8, 0x49, - 0x12, 0xfe, 0x18, 0xc0, 0x17, 0xa3, 0x14, 0xa7, 0x1f, 0x5f, 0x8a, 0x7b, 0x6e, 0x94, 0x52, 0x9c, - 0x30, 0xe1, 0x60, 0x39, 0xce, 0x7a, 0x74, 0x39, 0xee, 0xe6, 0x88, 0xe5, 0x38, 0xd1, 0xcf, 0x17, - 0xe4, 0xdd, 0xc4, 0x3b, 0xc7, 0xbe, 0x9b, 0xb8, 0x31, 0x52, 0x95, 0x4a, 0xcc, 0xfa, 0x2b, 0xfd, - 0x76, 0x22, 0xfe, 0xc0, 0x41, 0x81, 0xc9, 0xf0, 0x40, 0x47, 0x2f, 0xc3, 0x39, 0x71, 0x0d, 0x2f, - 0x4e, 0xdb, 0xab, 0xd9, 0x6e, 0xf0, 0xb5, 0x50, 0x0c, 0x5d, 0x84, 0x71, 0xcf, 0x27, 0xc4, 0x14, - 0x57, 0xa7, 0xbc, 0x81, 0x9e, 0x82, 0xb2, 0xeb, 0x11, 0xc3, 0xf2, 0xa9, 0xe7, 0x36, 0xad, 0xc0, - 0x67, 0x87, 0xe7, 0x98, 0x36, 0x2d, 0xa9, 0x35, 0x2b, 0xf0, 0xd5, 0x0e, 0x7f, 0xb9, 0xc9, 0x86, - 0xb2, 0x09, 0x53, 0x6e, 0x1b, 0x5b, 0x76, 0x40, 0x1e, 0x84, 0x69, 0xd7, 0x8d, 0x11, 0x02, 0x0a, - 0x2e, 0xa8, 0x45, 0x18, 0x68, 0x06, 0x0a, 0x34, 0x72, 0xe7, 0xe3, 0xa2, 0x9f, 0xea, 0x55, 0x28, - 0x53, 0xee, 0x55, 0xcb, 0x6d, 0x11, 0x8f, 0xf1, 0xa4, 0xdf, 0xe9, 0x1b, 0x30, 0x9d, 0x40, 0x45, - 0xdf, 0x86, 0x09, 0x9f, 0xd8, 0xa6, 0xbc, 0x0d, 0xcf, 0xaa, 0x25, 0x21, 0x85, 0x10, 0x8c, 0xb1, - 0x69, 0xf1, 0x47, 0xa1, 0xec, 0x5b, 0xfd, 0x43, 0x81, 0x4f, 0x9e, 0x15, 0x52, 0x1a, 0xfd, 0x85, - 0x94, 0x5b, 0xa3, 0x5c, 0x57, 0xa6, 0x95, 0x51, 0x36, 0xfa, 0xca, 0x28, 0x37, 0x47, 0x02, 0x1c, - 0x28, 0xa2, 0xfc, 0x26, 0x56, 0x44, 0xd1, 0x00, 0x0c, 0xa9, 0x42, 0x31, 0xde, 0xa5, 0xac, 0xf0, - 0x91, 0xf2, 0xb5, 0x18, 0x4a, 0xd2, 0xfa, 0xf9, 0xd3, 0x5b, 0x7f, 0x6e, 0x57, 0xd6, 0x45, 0x3e, - 0x83, 0xe1, 0xd6, 0x8a, 0xb1, 0x0b, 0x66, 0xf5, 0x3f, 0x61, 0x1d, 0x81, 0xf9, 0x71, 0xf8, 0xe8, - 0x41, 0x19, 0xf1, 0xd1, 0x03, 0x9a, 0x83, 0xc9, 0x70, 0x63, 0x16, 0xf9, 0x80, 0x6c, 0xa3, 0x79, - 0x00, 0x0f, 0xdb, 0xa6, 0xd3, 0xb1, 0xde, 0x95, 0xc5, 0x83, 0x18, 0x85, 0xae, 0xb7, 0x1e, 0xa6, - 0xb1, 0x7d, 0xb3, 0xcd, 0x9f, 0x2e, 0x84, 0x09, 0x2b, 0xa3, 0xd6, 0x04, 0x91, 0xa6, 0xc0, 0x2c, - 0x63, 0x92, 0x6c, 0xba, 0xc7, 0xae, 0xc7, 0x4b, 0x2c, 0xba, 0x72, 0xf6, 0x42, 0x46, 0x2d, 0x85, - 0xd3, 0x67, 0x51, 0x7e, 0x3f, 0xe7, 0x96, 0xfa, 0x81, 0xac, 0x0a, 0xb0, 0xe9, 0x2f, 0xc3, 0x38, - 0xeb, 0x53, 0xcc, 0xff, 0xc9, 0x21, 0xf3, 0xdf, 0xa6, 0xbc, 0x1a, 0x17, 0x41, 0xeb, 0x50, 0x32, - 0x89, 0x1f, 0xe8, 0xe1, 0x96, 0x94, 0x1f, 0x69, 0xb1, 0x15, 0xa9, 0xec, 0x4a, 0xff, 0xb6, 0x54, - 0xe8, 0xdb, 0x96, 0x3e, 0x27, 0x35, 0xd5, 0xfe, 0x96, 0xff, 0xf0, 0xe1, 0xbc, 0xf2, 0xd1, 0xc3, - 0x79, 0xe5, 0x93, 0x87, 0xf3, 0xca, 0xfb, 0x9f, 0xce, 0xe7, 0x3e, 0xfa, 0x74, 0x3e, 0xf7, 0x97, - 0x4f, 0xe7, 0x73, 0x70, 0xd5, 0x70, 0x3a, 0x19, 0xfc, 0xb1, 0x36, 0x13, 0x4f, 0x48, 0x3d, 0x27, - 0x70, 0x1a, 0xca, 0x5b, 0xcd, 0x7d, 0x2b, 0x68, 0x75, 0x9b, 0x55, 0xc3, 0xe9, 0x2c, 0x1a, 0x8e, - 0xdf, 0x71, 0xfc, 0x45, 0x8f, 0xb4, 0xf1, 0x11, 0xf1, 0x16, 0x7b, 0x4b, 0xf2, 0x93, 0xe5, 0x8d, - 0xfe, 0xe2, 0xf0, 0x5f, 0xbe, 0xbc, 0x18, 0x23, 0x86, 0xb4, 0x5f, 0xe5, 0x0b, 0x8d, 0xd5, 0x37, - 0x7e, 0x9d, 0x57, 0x1b, 0xe1, 0x10, 0x57, 0xe9, 0x10, 0x63, 0x83, 0xa9, 0x6e, 0x0b, 0xd6, 0x3f, - 0x46, 0x4c, 0xbb, 0x94, 0x69, 0x37, 0xc6, 0xb4, 0x1b, 0x32, 0x3d, 0xcc, 0x57, 0x87, 0x33, 0xed, - 0xbe, 0xda, 0xa8, 0x85, 0xcf, 0xbb, 0xfe, 0x91, 0x7f, 0x2a, 0x14, 0x58, 0x5e, 0xa6, 0x12, 0xcb, - 0xcb, 0x31, 0x91, 0xe5, 0xe5, 0x50, 0xa6, 0x39, 0xc1, 0x7e, 0xb1, 0x72, 0xf3, 0xbf, 0x01, 0x00, - 0x00, 0xff, 0xff, 0x96, 0xcf, 0xfa, 0xae, 0xe3, 0x33, 0x00, 0x00, + return len(dAtA) - i, nil } -func (m *Transaction) Marshal() (dAtA []byte, err error) { +func (m *PayloadKeyWithCommitment) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -3755,19 +3408,19 @@ func (m *Transaction) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Transaction) MarshalTo(dAtA []byte) (int, error) { +func (m *PayloadKeyWithCommitment) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Transaction) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PayloadKeyWithCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Anchor != nil { + if m.Commitment != nil { { - size, err := m.Anchor.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Commitment.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -3775,18 +3428,11 @@ func (m *Transaction) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a - } - if len(m.BindingSig) > 0 { - i -= len(m.BindingSig) - copy(dAtA[i:], m.BindingSig) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.BindingSig))) - i-- dAtA[i] = 0x12 } - if m.Body != nil { + if m.PayloadKey != nil { { - size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.PayloadKey.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -3799,7 +3445,7 @@ func (m *Transaction) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Id) Marshal() (dAtA []byte, err error) { +func (m *NullifierWithNote) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -3809,57 +3455,44 @@ func (m *Id) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Id) MarshalTo(dAtA []byte) (int, error) { +func (m *NullifierWithNote) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Id) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *NullifierWithNote) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Hash) > 0 { - i -= len(m.Hash) - copy(dAtA[i:], m.Hash) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Hash))) + if m.Note != nil { + { + size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *EffectHash) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x12 } - return dAtA[:n], nil -} - -func (m *EffectHash) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *EffectHash) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Inner))) + if m.Nullifier != nil { + { + size, err := m.Nullifier.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *TransactionBody) Marshal() (dAtA []byte, err error) { +func (m *TransactionView) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -3869,19 +3502,19 @@ func (m *TransactionBody) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TransactionBody) MarshalTo(dAtA []byte) (int, error) { +func (m *TransactionView) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TransactionBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TransactionView) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.MemoData != nil { + if m.Anchor != nil { { - size, err := m.MemoData.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Anchor.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -3889,23 +3522,11 @@ func (m *TransactionBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x2a - } - if m.DetectionData != nil { - { - size, err := m.DetectionData.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 + dAtA[i] = 0x1a } - if m.Fee != nil { + if m.BindingSig != nil { { - size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.BindingSig.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -3913,11 +3534,11 @@ func (m *TransactionBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a + dAtA[i] = 0x12 } - if m.TransactionParameters != nil { + if m.BodyView != nil { { - size, err := m.TransactionParameters.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.BodyView.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -3925,26 +3546,12 @@ func (m *TransactionBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x12 - } - if len(m.Actions) > 0 { - for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Actions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *MemoData) Marshal() (dAtA []byte, err error) { +func (m *TransactionBodyView) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -3954,103 +3561,56 @@ func (m *MemoData) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MemoData) MarshalTo(dAtA []byte) (int, error) { +func (m *TransactionBodyView) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemoData) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TransactionBodyView) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.XEncryptedMemo != nil { + if m.MemoView != nil { { - size := m.XEncryptedMemo.Size() - i -= size - if _, err := m.XEncryptedMemo.MarshalTo(dAtA[i:]); err != nil { + size, err := m.MemoView.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { return 0, err } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - } - return len(dAtA) - i, nil -} - -func (m *MemoData_EncryptedMemo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MemoData_EncryptedMemo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.EncryptedMemo != nil { - i -= len(m.EncryptedMemo) - copy(dAtA[i:], m.EncryptedMemo) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.EncryptedMemo))) i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *TransactionParameters) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x2a } - return dAtA[:n], nil -} - -func (m *TransactionParameters) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TransactionParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ChainId) > 0 { - i -= len(m.ChainId) - copy(dAtA[i:], m.ChainId) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.ChainId))) + if m.DetectionData != nil { + { + size, err := m.DetectionData.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x22 } - if m.ExpiryHeight != 0 { - i = encodeVarintTransaction(dAtA, i, uint64(m.ExpiryHeight)) + if m.TransactionParameters != nil { + { + size, err := m.TransactionParameters.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *DetectionData) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x12 } - return dAtA[:n], nil -} - -func (m *DetectionData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DetectionData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.FmdClues) > 0 { - for iNdEx := len(m.FmdClues) - 1; iNdEx >= 0; iNdEx-- { + if len(m.ActionViews) > 0 { + for iNdEx := len(m.ActionViews) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.FmdClues[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ActionViews[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4058,13 +3618,13 @@ func (m *DetectionData) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x22 + dAtA[i] = 0xa } } return len(dAtA) - i, nil } -func (m *Action) Marshal() (dAtA []byte, err error) { +func (m *ActionView) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4074,21 +3634,21 @@ func (m *Action) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Action) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Action != nil { + if m.ActionView != nil { { - size := m.Action.Size() + size := m.ActionView.Size() i -= size - if _, err := m.Action.MarshalTo(dAtA[i:]); err != nil { + if _, err := m.ActionView.MarshalTo(dAtA[i:]); err != nil { return 0, err } } @@ -4096,12 +3656,12 @@ func (m *Action) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Action_Spend) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_Spend) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Spend != nil { { @@ -4117,12 +3677,12 @@ func (m *Action_Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_Output) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_Output) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_Output) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_Output) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Output != nil { { @@ -4138,12 +3698,12 @@ func (m *Action_Output) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_Swap) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_Swap) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Swap != nil { { @@ -4159,12 +3719,12 @@ func (m *Action_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_SwapClaim) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_SwapClaim) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.SwapClaim != nil { { @@ -4180,12 +3740,12 @@ func (m *Action_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ValidatorDefinition != nil { { @@ -4203,16 +3763,16 @@ func (m *Action_ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, err } return len(dAtA) - i, nil } -func (m *Action_IbcAction) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_IbcRelayAction) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_IbcAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_IbcRelayAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.IbcAction != nil { + if m.IbcRelayAction != nil { { - size, err := m.IbcAction.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.IbcRelayAction.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4226,12 +3786,12 @@ func (m *Action_IbcAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_ProposalSubmit) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_ProposalSubmit) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ProposalSubmit != nil { { @@ -4249,12 +3809,12 @@ func (m *Action_ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_ProposalWithdraw) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_ProposalWithdraw) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ProposalWithdraw != nil { { @@ -4272,12 +3832,12 @@ func (m *Action_ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) } return len(dAtA) - i, nil } -func (m *Action_ValidatorVote) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_ValidatorVote) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ValidatorVote != nil { { @@ -4295,12 +3855,12 @@ func (m *Action_ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_DelegatorVote) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_DelegatorVote) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.DelegatorVote != nil { { @@ -4318,12 +3878,12 @@ func (m *Action_DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_ProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_ProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ProposalDepositClaim != nil { { @@ -4341,12 +3901,12 @@ func (m *Action_ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, er } return len(dAtA) - i, nil } -func (m *Action_PositionOpen) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_PositionOpen) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.PositionOpen != nil { { @@ -4364,12 +3924,12 @@ func (m *Action_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_PositionClose) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_PositionClose) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.PositionClose != nil { { @@ -4387,12 +3947,12 @@ func (m *Action_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_PositionWithdraw) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_PositionWithdraw) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.PositionWithdraw != nil { { @@ -4410,12 +3970,12 @@ func (m *Action_PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) } return len(dAtA) - i, nil } -func (m *Action_PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.PositionRewardClaim != nil { { @@ -4433,12 +3993,12 @@ func (m *Action_PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, err } return len(dAtA) - i, nil } -func (m *Action_Delegate) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_Delegate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Delegate != nil { { @@ -4452,16 +4012,16 @@ func (m *Action_Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x2 i-- - dAtA[i] = 0xc2 + dAtA[i] = 0xca } return len(dAtA) - i, nil } -func (m *Action_Undelegate) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_Undelegate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Undelegate != nil { { @@ -4475,16 +4035,16 @@ func (m *Action_Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x2 i-- - dAtA[i] = 0xca + dAtA[i] = 0xd2 } return len(dAtA) - i, nil } -func (m *Action_UndelegateClaim) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_UndelegateClaim) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.UndelegateClaim != nil { { @@ -4498,20 +4058,20 @@ func (m *Action_UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) i-- dAtA[i] = 0x2 i-- - dAtA[i] = 0xd2 + dAtA[i] = 0xda } return len(dAtA) - i, nil } -func (m *Action_DaoSpend) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_CommunityPoolSpend) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_DaoSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_CommunityPoolSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.DaoSpend != nil { + if m.CommunityPoolSpend != nil { { - size, err := m.DaoSpend.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.CommunityPoolSpend.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4525,16 +4085,16 @@ func (m *Action_DaoSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_DaoOutput) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_CommunityPoolOutput) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_DaoOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_CommunityPoolOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.DaoOutput != nil { + if m.CommunityPoolOutput != nil { { - size, err := m.DaoOutput.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.CommunityPoolOutput.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4548,16 +4108,16 @@ func (m *Action_DaoOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_DaoDeposit) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_CommunityPoolDeposit) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_DaoDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_CommunityPoolDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.DaoDeposit != nil { + if m.CommunityPoolDeposit != nil { { - size, err := m.DaoDeposit.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.CommunityPoolDeposit.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4571,12 +4131,12 @@ func (m *Action_DaoDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Action_Ics20Withdrawal) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionView_Ics20Withdrawal) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Action_Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionView_Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Ics20Withdrawal != nil { { @@ -4594,7 +4154,7 @@ func (m *Action_Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) } return len(dAtA) - i, nil } -func (m *TransactionPerspective) Marshal() (dAtA []byte, err error) { +func (m *AuthorizationData) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4604,32 +4164,20 @@ func (m *TransactionPerspective) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TransactionPerspective) MarshalTo(dAtA []byte) (int, error) { +func (m *AuthorizationData) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TransactionPerspective) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AuthorizationData) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.TransactionId != nil { - { - size, err := m.TransactionId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - if len(m.Denoms) > 0 { - for iNdEx := len(m.Denoms) - 1; iNdEx >= 0; iNdEx-- { + if len(m.DelegatorVoteAuths) > 0 { + for iNdEx := len(m.DelegatorVoteAuths) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.Denoms[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.DelegatorVoteAuths[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4637,41 +4185,13 @@ func (m *TransactionPerspective) MarshalToSizedBuffer(dAtA []byte) (int, error) i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x2a + dAtA[i] = 0x1a } } - if len(m.AddressViews) > 0 { - for iNdEx := len(m.AddressViews) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.AddressViews[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - } - if len(m.AdviceNotes) > 0 { - for iNdEx := len(m.AdviceNotes) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.AdviceNotes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - } - if len(m.SpendNullifiers) > 0 { - for iNdEx := len(m.SpendNullifiers) - 1; iNdEx >= 0; iNdEx-- { + if len(m.SpendAuths) > 0 { + for iNdEx := len(m.SpendAuths) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.SpendNullifiers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.SpendAuths[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4682,24 +4202,22 @@ func (m *TransactionPerspective) MarshalToSizedBuffer(dAtA []byte) (int, error) dAtA[i] = 0x12 } } - if len(m.PayloadKeys) > 0 { - for iNdEx := len(m.PayloadKeys) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PayloadKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) + if m.EffectHash != nil { + { + size, err := m.EffectHash.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0xa + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *PayloadKey) Marshal() (dAtA []byte, err error) { +func (m *WitnessData) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4709,27 +4227,46 @@ func (m *PayloadKey) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *PayloadKey) MarshalTo(dAtA []byte) (int, error) { +func (m *WitnessData) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PayloadKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *WitnessData) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Inner))) + if len(m.StateCommitmentProofs) > 0 { + for iNdEx := len(m.StateCommitmentProofs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.StateCommitmentProofs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.Anchor != nil { + { + size, err := m.Anchor.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *PayloadKeyWithCommitment) Marshal() (dAtA []byte, err error) { +func (m *TransactionPlan) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4739,19 +4276,19 @@ func (m *PayloadKeyWithCommitment) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *PayloadKeyWithCommitment) MarshalTo(dAtA []byte) (int, error) { +func (m *TransactionPlan) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PayloadKeyWithCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TransactionPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Commitment != nil { + if m.Memo != nil { { - size, err := m.Commitment.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Memo.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4759,11 +4296,11 @@ func (m *PayloadKeyWithCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x2a } - if m.PayloadKey != nil { + if m.DetectionData != nil { { - size, err := m.PayloadKey.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.DetectionData.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4771,34 +4308,11 @@ func (m *PayloadKeyWithCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *NullifierWithNote) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x22 } - return dAtA[:n], nil -} - -func (m *NullifierWithNote) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NullifierWithNote) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Note != nil { + if m.TransactionParameters != nil { { - size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.TransactionParameters.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4808,22 +4322,24 @@ func (m *NullifierWithNote) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if m.Nullifier != nil { - { - size, err := m.Nullifier.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.Actions) > 0 { + for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Actions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *TransactionView) Marshal() (dAtA []byte, err error) { +func (m *DetectionDataPlan) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4833,51 +4349,34 @@ func (m *TransactionView) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TransactionView) MarshalTo(dAtA []byte) (int, error) { +func (m *DetectionDataPlan) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TransactionView) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *DetectionDataPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Anchor != nil { - { - size, err := m.Anchor.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if len(m.BindingSig) > 0 { - i -= len(m.BindingSig) - copy(dAtA[i:], m.BindingSig) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.BindingSig))) - i-- - dAtA[i] = 0x12 - } - if m.BodyView != nil { - { - size, err := m.BodyView.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.CluePlans) > 0 { + for iNdEx := len(m.CluePlans) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.CluePlans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *TransactionBodyView) Marshal() (dAtA []byte, err error) { +func (m *ActionPlan) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4887,37 +4386,38 @@ func (m *TransactionBodyView) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TransactionBodyView) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TransactionBodyView) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.XMemoView != nil { - { - size := m.XMemoView.Size() - i -= size - if _, err := m.XMemoView.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - if m.XDetectionData != nil { + if m.Action != nil { { - size := m.XDetectionData.Size() + size := m.Action.Size() i -= size - if _, err := m.XDetectionData.MarshalTo(dAtA[i:]); err != nil { + if _, err := m.Action.MarshalTo(dAtA[i:]); err != nil { return 0, err } } } - if m.Fee != nil { + return len(dAtA) - i, nil +} + +func (m *ActionPlan_Spend) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ActionPlan_Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Spend != nil { { - size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Spend.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4925,11 +4425,20 @@ func (m *TransactionBodyView) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a + dAtA[i] = 0xa } - if m.TransactionParameters != nil { + return len(dAtA) - i, nil +} +func (m *ActionPlan_Output) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ActionPlan_Output) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Output != nil { { - size, err := m.TransactionParameters.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4939,33 +4448,18 @@ func (m *TransactionBodyView) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if len(m.ActionViews) > 0 { - for iNdEx := len(m.ActionViews) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.ActionViews[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } return len(dAtA) - i, nil } - -func (m *TransactionBodyView_DetectionData) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_Swap) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TransactionBodyView_DetectionData) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.DetectionData != nil { + if m.Swap != nil { { - size, err := m.DetectionData.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4973,134 +4467,18 @@ func (m *TransactionBodyView_DetectionData) MarshalToSizedBuffer(dAtA []byte) (i i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x22 + dAtA[i] = 0x1a } return len(dAtA) - i, nil } -func (m *TransactionBodyView_MemoView) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_SwapClaim) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TransactionBodyView_MemoView) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.MemoView != nil { - { - size, err := m.MemoView.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - return len(dAtA) - i, nil -} -func (m *ActionView) 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 *ActionView) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ActionView) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.ActionView != nil { - { - size := m.ActionView.Size() - i -= size - if _, err := m.ActionView.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *ActionView_Spend) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ActionView_Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Spend != nil { - { - size, err := m.Spend.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *ActionView_Output) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ActionView_Output) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Output != nil { - { - size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *ActionView_Swap) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ActionView_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Swap != nil { - { - size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - return len(dAtA) - i, nil -} -func (m *ActionView_SwapClaim) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ActionView_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.SwapClaim != nil { + if m.SwapClaim != nil { { size, err := m.SwapClaim.MarshalToSizedBuffer(dAtA[:i]) if err != nil { @@ -5114,12 +4492,12 @@ func (m *ActionView_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *ActionView_ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ValidatorDefinition != nil { { @@ -5137,16 +4515,16 @@ func (m *ActionView_ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, } return len(dAtA) - i, nil } -func (m *ActionView_IbcAction) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_IbcRelayAction) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_IbcAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_IbcRelayAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.IbcAction != nil { + if m.IbcRelayAction != nil { { - size, err := m.IbcAction.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.IbcRelayAction.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5160,12 +4538,12 @@ func (m *ActionView_IbcAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *ActionView_ProposalSubmit) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_ProposalSubmit) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ProposalSubmit != nil { { @@ -5183,12 +4561,12 @@ func (m *ActionView_ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, erro } return len(dAtA) - i, nil } -func (m *ActionView_ProposalWithdraw) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_ProposalWithdraw) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ProposalWithdraw != nil { { @@ -5206,12 +4584,12 @@ func (m *ActionView_ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, er } return len(dAtA) - i, nil } -func (m *ActionView_ValidatorVote) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_ValidatorVote) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ValidatorVote != nil { { @@ -5229,12 +4607,12 @@ func (m *ActionView_ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error } return len(dAtA) - i, nil } -func (m *ActionView_DelegatorVote) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_DelegatorVote) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.DelegatorVote != nil { { @@ -5252,12 +4630,12 @@ func (m *ActionView_DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error } return len(dAtA) - i, nil } -func (m *ActionView_ProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_ProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.ProposalDepositClaim != nil { { @@ -5275,12 +4653,35 @@ func (m *ActionView_ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int } return len(dAtA) - i, nil } -func (m *ActionView_PositionOpen) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_Withdrawal) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Withdrawal != nil { + { + size, err := m.Withdrawal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xba + } + return len(dAtA) - i, nil +} +func (m *ActionPlan_PositionOpen) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ActionPlan_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.PositionOpen != nil { { @@ -5298,12 +4699,12 @@ func (m *ActionView_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) } return len(dAtA) - i, nil } -func (m *ActionView_PositionClose) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_PositionClose) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.PositionClose != nil { { @@ -5321,12 +4722,12 @@ func (m *ActionView_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error } return len(dAtA) - i, nil } -func (m *ActionView_PositionWithdraw) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_PositionWithdraw) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.PositionWithdraw != nil { { @@ -5344,12 +4745,12 @@ func (m *ActionView_PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, er } return len(dAtA) - i, nil } -func (m *ActionView_PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.PositionRewardClaim != nil { { @@ -5367,12 +4768,12 @@ func (m *ActionView_PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, } return len(dAtA) - i, nil } -func (m *ActionView_Delegate) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_Delegate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Delegate != nil { { @@ -5386,16 +4787,16 @@ func (m *ActionView_Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x2 i-- - dAtA[i] = 0xca + dAtA[i] = 0xc2 } return len(dAtA) - i, nil } -func (m *ActionView_Undelegate) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_Undelegate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Undelegate != nil { { @@ -5409,16 +4810,16 @@ func (m *ActionView_Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x2 i-- - dAtA[i] = 0xd2 + dAtA[i] = 0xca } return len(dAtA) - i, nil } -func (m *ActionView_UndelegateClaim) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_UndelegateClaim) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.UndelegateClaim != nil { { @@ -5432,20 +4833,20 @@ func (m *ActionView_UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, err i-- dAtA[i] = 0x2 i-- - dAtA[i] = 0xda + dAtA[i] = 0xd2 } return len(dAtA) - i, nil } -func (m *ActionView_DaoSpend) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_CommunityPoolSpend) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_DaoSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_CommunityPoolSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.DaoSpend != nil { + if m.CommunityPoolSpend != nil { { - size, err := m.DaoSpend.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.CommunityPoolSpend.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5459,16 +4860,16 @@ func (m *ActionView_DaoSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *ActionView_DaoOutput) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_CommunityPoolOutput) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_DaoOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_CommunityPoolOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.DaoOutput != nil { + if m.CommunityPoolOutput != nil { { - size, err := m.DaoOutput.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.CommunityPoolOutput.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5482,16 +4883,16 @@ func (m *ActionView_DaoOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *ActionView_DaoDeposit) MarshalTo(dAtA []byte) (int, error) { +func (m *ActionPlan_CommunityPoolDeposit) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_DaoDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ActionPlan_CommunityPoolDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.DaoDeposit != nil { + if m.CommunityPoolDeposit != nil { { - size, err := m.DaoDeposit.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.CommunityPoolDeposit.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5505,16 +4906,41 @@ func (m *ActionView_DaoDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *ActionView_Ics20Withdrawal) MarshalTo(dAtA []byte) (int, error) { +func (m *CluePlan) 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 *CluePlan) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ActionView_Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *CluePlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Ics20Withdrawal != nil { + _ = i + var l int + _ = l + if m.PrecisionBits != 0 { + i = encodeVarintTransaction(dAtA, i, uint64(m.PrecisionBits)) + i-- + dAtA[i] = 0x18 + } + if len(m.Rseed) > 0 { + i -= len(m.Rseed) + copy(dAtA[i:], m.Rseed) + i = encodeVarintTransaction(dAtA, i, uint64(len(m.Rseed))) + i-- + dAtA[i] = 0x12 + } + if m.Address != nil { { - size, err := m.Ics20Withdrawal.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5522,13 +4948,12 @@ func (m *ActionView_Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, err i = encodeVarintTransaction(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xc - i-- - dAtA[i] = 0xc2 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SpendView) Marshal() (dAtA []byte, err error) { + +func (m *MemoPlan) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5538,71 +4963,69 @@ func (m *SpendView) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SpendView) MarshalTo(dAtA []byte) (int, error) { +func (m *MemoPlan) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SpendView) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MemoPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.SpendView != nil { + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintTransaction(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + } + if m.Plaintext != nil { { - size := m.SpendView.Size() - i -= size - if _, err := m.SpendView.MarshalTo(dAtA[i:]); err != nil { + size, err := m.Plaintext.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { return 0, err } + i -= size + i = encodeVarintTransaction(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SpendView_Visible_) MarshalTo(dAtA []byte) (int, error) { +func (m *MemoCiphertext) Marshal() (dAtA []byte, err error) { size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SpendView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Visible != nil { - { - size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return len(dAtA) - i, nil + return dAtA[:n], nil } -func (m *SpendView_Opaque_) MarshalTo(dAtA []byte) (int, error) { + +func (m *MemoCiphertext) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SpendView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MemoCiphertext) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Opaque != nil { - { - size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintTransaction(dAtA, i, uint64(len(m.Inner))) i-- - dAtA[i] = 0x12 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SpendView_Visible) Marshal() (dAtA []byte, err error) { + +func (m *MemoPlaintext) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5612,31 +5035,26 @@ func (m *SpendView_Visible) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SpendView_Visible) MarshalTo(dAtA []byte) (int, error) { +func (m *MemoPlaintext) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SpendView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MemoPlaintext) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Note != nil { - { - size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } + if len(m.Text) > 0 { + i -= len(m.Text) + copy(dAtA[i:], m.Text) + i = encodeVarintTransaction(dAtA, i, uint64(len(m.Text))) i-- dAtA[i] = 0x12 } - if m.Spend != nil { + if m.ReturnAddress != nil { { - size, err := m.Spend.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ReturnAddress.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5649,7 +5067,7 @@ func (m *SpendView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SpendView_Opaque) Marshal() (dAtA []byte, err error) { +func (m *MemoPlaintextView) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5659,19 +5077,26 @@ func (m *SpendView_Opaque) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SpendView_Opaque) MarshalTo(dAtA []byte) (int, error) { +func (m *MemoPlaintextView) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SpendView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MemoPlaintextView) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Spend != nil { + if len(m.Text) > 0 { + i -= len(m.Text) + copy(dAtA[i:], m.Text) + i = encodeVarintTransaction(dAtA, i, uint64(len(m.Text))) + i-- + dAtA[i] = 0x12 + } + if m.ReturnAddress != nil { { - size, err := m.Spend.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ReturnAddress.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5684,7 +5109,7 @@ func (m *SpendView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *DelegatorVoteView) Marshal() (dAtA []byte, err error) { +func (m *MemoView) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5694,21 +5119,21 @@ func (m *DelegatorVoteView) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DelegatorVoteView) MarshalTo(dAtA []byte) (int, error) { +func (m *MemoView) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DelegatorVoteView) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MemoView) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DelegatorVote != nil { + if m.MemoView != nil { { - size := m.DelegatorVote.Size() + size := m.MemoView.Size() i -= size - if _, err := m.DelegatorVote.MarshalTo(dAtA[i:]); err != nil { + if _, err := m.MemoView.MarshalTo(dAtA[i:]); err != nil { return 0, err } } @@ -5716,12 +5141,12 @@ func (m *DelegatorVoteView) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *DelegatorVoteView_Visible_) MarshalTo(dAtA []byte) (int, error) { +func (m *MemoView_Visible_) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DelegatorVoteView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MemoView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Visible != nil { { @@ -5737,12 +5162,12 @@ func (m *DelegatorVoteView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, err } return len(dAtA) - i, nil } -func (m *DelegatorVoteView_Opaque_) MarshalTo(dAtA []byte) (int, error) { +func (m *MemoView_Opaque_) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DelegatorVoteView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MemoView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Opaque != nil { { @@ -5758,7 +5183,7 @@ func (m *DelegatorVoteView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, erro } return len(dAtA) - i, nil } -func (m *DelegatorVoteView_Visible) Marshal() (dAtA []byte, err error) { +func (m *MemoView_Visible) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5768,19 +5193,19 @@ func (m *DelegatorVoteView_Visible) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DelegatorVoteView_Visible) MarshalTo(dAtA []byte) (int, error) { +func (m *MemoView_Visible) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DelegatorVoteView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MemoView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Note != nil { + if m.Plaintext != nil { { - size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Plaintext.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5790,9 +5215,9 @@ func (m *DelegatorVoteView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, erro i-- dAtA[i] = 0x12 } - if m.DelegatorVote != nil { + if m.Ciphertext != nil { { - size, err := m.DelegatorVote.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Ciphertext.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5805,7 +5230,7 @@ func (m *DelegatorVoteView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, erro return len(dAtA) - i, nil } -func (m *DelegatorVoteView_Opaque) Marshal() (dAtA []byte, err error) { +func (m *MemoView_Opaque) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5815,19 +5240,19 @@ func (m *DelegatorVoteView_Opaque) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DelegatorVoteView_Opaque) MarshalTo(dAtA []byte) (int, error) { +func (m *MemoView_Opaque) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DelegatorVoteView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MemoView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DelegatorVote != nil { + if m.Ciphertext != nil { { - size, err := m.DelegatorVote.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Ciphertext.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5840,1868 +5265,1020 @@ func (m *DelegatorVoteView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error return len(dAtA) - i, nil } -func (m *OutputView) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func encodeVarintTransaction(dAtA []byte, offset int, v uint64) int { + offset -= sovTransaction(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ } - return dAtA[:n], nil + dAtA[offset] = uint8(v) + return base } - -func (m *OutputView) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *Transaction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Body != nil { + l = m.Body.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.BindingSig != nil { + l = m.BindingSig.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.Anchor != nil { + l = m.Anchor.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *OutputView) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i +func (m *TransactionBody) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if m.OutputView != nil { - { - size := m.OutputView.Size() - i -= size - if _, err := m.OutputView.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } + if len(m.Actions) > 0 { + for _, e := range m.Actions { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } } - return len(dAtA) - i, nil + if m.TransactionParameters != nil { + l = m.TransactionParameters.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.DetectionData != nil { + l = m.DetectionData.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.Memo != nil { + l = m.Memo.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *OutputView_Visible_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *TransactionParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ExpiryHeight != 0 { + n += 1 + sovTransaction(uint64(m.ExpiryHeight)) + } + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovTransaction(uint64(l)) + } + if m.Fee != nil { + l = m.Fee.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *OutputView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Visible != nil { - { - size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) +func (m *DetectionData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.FmdClues) > 0 { + for _, e := range m.FmdClues { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } - i-- - dAtA[i] = 0xa } - return len(dAtA) - i, nil -} -func (m *OutputView_Opaque_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } -func (m *OutputView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Opaque != nil { - { - size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 +func (m *Action) Size() (n int) { + if m == nil { + return 0 } - return len(dAtA) - i, nil -} -func (m *OutputView_Visible) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + var l int + _ = l + if m.Action != nil { + n += m.Action.Size() } - return dAtA[:n], nil -} - -func (m *OutputView_Visible) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } -func (m *OutputView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i +func (m *Action_Spend) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if m.PayloadKey != nil { - { - size, err := m.PayloadKey.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a + if m.Spend != nil { + l = m.Spend.Size() + n += 1 + l + sovTransaction(uint64(l)) } - if m.Note != nil { - { - size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + return n +} +func (m *Action_Output) Size() (n int) { + if m == nil { + return 0 } + var l int + _ = l if m.Output != nil { - { - size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + l = m.Output.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil + return n } - -func (m *OutputView_Opaque) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *Action_Swap) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *OutputView_Opaque) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *OutputView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if m.Output != nil { - { - size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + if m.Swap != nil { + l = m.Swap.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil + return n } - -func (m *Spend) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *Action_SwapClaim) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *Spend) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if m.Proof != nil { - { - size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a + if m.SwapClaim != nil { + l = m.SwapClaim.Size() + n += 1 + l + sovTransaction(uint64(l)) } - if m.AuthSig != nil { - { - size, err := m.AuthSig.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + return n +} +func (m *Action_ValidatorDefinition) Size() (n int) { + if m == nil { + return 0 } - if m.Body != nil { - { - size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + var l int + _ = l + if m.ValidatorDefinition != nil { + l = m.ValidatorDefinition.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil + return n } - -func (m *SpendBody) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *Action_IbcRelayAction) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SpendBody) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SpendBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if len(m.Rk) > 0 { - i -= len(m.Rk) - copy(dAtA[i:], m.Rk) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Rk))) - i-- - dAtA[i] = 0x22 + if m.IbcRelayAction != nil { + l = m.IbcRelayAction.Size() + n += 2 + l + sovTransaction(uint64(l)) } - if len(m.Nullifier) > 0 { - i -= len(m.Nullifier) - copy(dAtA[i:], m.Nullifier) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Nullifier))) - i-- - dAtA[i] = 0x1a + return n +} +func (m *Action_ProposalSubmit) Size() (n int) { + if m == nil { + return 0 } - if m.BalanceCommitment != nil { - { - size, err := m.BalanceCommitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + var l int + _ = l + if m.ProposalSubmit != nil { + l = m.ProposalSubmit.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil + return n } - -func (m *Output) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *Action_ProposalWithdraw) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *Output) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Output) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if m.Proof != nil { - { - size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Body != nil { - { - size, err := m.Body.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + if m.ProposalWithdraw != nil { + l = m.ProposalWithdraw.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil + return n } - -func (m *OutputBody) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *Action_ValidatorVote) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *OutputBody) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + var l int + _ = l + if m.ValidatorVote != nil { + l = m.ValidatorVote.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *OutputBody) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i +func (m *Action_DelegatorVote) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.OvkWrappedKey) > 0 { - i -= len(m.OvkWrappedKey) - copy(dAtA[i:], m.OvkWrappedKey) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.OvkWrappedKey))) - i-- - dAtA[i] = 0x22 + if m.DelegatorVote != nil { + l = m.DelegatorVote.Size() + n += 2 + l + sovTransaction(uint64(l)) } - if len(m.WrappedMemoKey) > 0 { - i -= len(m.WrappedMemoKey) - copy(dAtA[i:], m.WrappedMemoKey) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.WrappedMemoKey))) - i-- - dAtA[i] = 0x1a + return n +} +func (m *Action_ProposalDepositClaim) Size() (n int) { + if m == nil { + return 0 } - if m.BalanceCommitment != nil { - { - size, err := m.BalanceCommitment.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + var l int + _ = l + if m.ProposalDepositClaim != nil { + l = m.ProposalDepositClaim.Size() + n += 2 + l + sovTransaction(uint64(l)) } - if m.NotePayload != nil { - { - size, err := m.NotePayload.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + return n +} +func (m *Action_PositionOpen) Size() (n int) { + if m == nil { + return 0 } - return len(dAtA) - i, nil + var l int + _ = l + if m.PositionOpen != nil { + l = m.PositionOpen.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *AuthorizationData) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *Action_PositionClose) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil + var l int + _ = l + if m.PositionClose != nil { + l = m.PositionClose.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *AuthorizationData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *Action_PositionWithdraw) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PositionWithdraw != nil { + l = m.PositionWithdraw.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *AuthorizationData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i +func (m *Action_PositionRewardClaim) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.DelegatorVoteAuths) > 0 { - for iNdEx := len(m.DelegatorVoteAuths) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.DelegatorVoteAuths[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } + if m.PositionRewardClaim != nil { + l = m.PositionRewardClaim.Size() + n += 2 + l + sovTransaction(uint64(l)) } - if len(m.SpendAuths) > 0 { - for iNdEx := len(m.SpendAuths) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.SpendAuths[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } + return n +} +func (m *Action_Delegate) Size() (n int) { + if m == nil { + return 0 } - if m.EffectHash != nil { - { - size, err := m.EffectHash.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + var l int + _ = l + if m.Delegate != nil { + l = m.Delegate.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil + return n } - -func (m *WitnessData) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *Action_Undelegate) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil + var l int + _ = l + if m.Undelegate != nil { + l = m.Undelegate.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *WitnessData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *Action_UndelegateClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UndelegateClaim != nil { + l = m.UndelegateClaim.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *WitnessData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i +func (m *Action_CommunityPoolSpend) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.StateCommitmentProofs) > 0 { - for iNdEx := len(m.StateCommitmentProofs) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.StateCommitmentProofs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } + if m.CommunityPoolSpend != nil { + l = m.CommunityPoolSpend.Size() + n += 2 + l + sovTransaction(uint64(l)) } - if m.Anchor != nil { - { - size, err := m.Anchor.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + return n +} +func (m *Action_CommunityPoolOutput) Size() (n int) { + if m == nil { + return 0 } - return len(dAtA) - i, nil + var l int + _ = l + if m.CommunityPoolOutput != nil { + l = m.CommunityPoolOutput.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *TransactionPlan) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *Action_CommunityPoolDeposit) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil + var l int + _ = l + if m.CommunityPoolDeposit != nil { + l = m.CommunityPoolDeposit.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *TransactionPlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *Action_Ics20Withdrawal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Ics20Withdrawal != nil { + l = m.Ics20Withdrawal.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *TransactionPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i +func (m *TransactionPerspective) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if m.MemoPlan != nil { - { - size, err := m.MemoPlan.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) + if len(m.PayloadKeys) > 0 { + for _, e := range m.PayloadKeys { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } - i-- - dAtA[i] = 0x32 } - if len(m.CluePlans) > 0 { - for iNdEx := len(m.CluePlans) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.CluePlans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a + if len(m.SpendNullifiers) > 0 { + for _, e := range m.SpendNullifiers { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } } - if m.Fee != nil { - { - size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) + if len(m.AdviceNotes) > 0 { + for _, e := range m.AdviceNotes { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } - i-- - dAtA[i] = 0x22 - } - if len(m.ChainId) > 0 { - i -= len(m.ChainId) - copy(dAtA[i:], m.ChainId) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.ChainId))) - i-- - dAtA[i] = 0x1a } - if m.ExpiryHeight != 0 { - i = encodeVarintTransaction(dAtA, i, uint64(m.ExpiryHeight)) - i-- - dAtA[i] = 0x10 + if len(m.AddressViews) > 0 { + for _, e := range m.AddressViews { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) + } } - if len(m.Actions) > 0 { - for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Actions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + if len(m.Denoms) > 0 { + for _, e := range m.Denoms { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } } - return len(dAtA) - i, nil + if m.TransactionId != nil { + l = m.TransactionId.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *ActionPlan) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *PayloadKeyWithCommitment) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil + var l int + _ = l + if m.PayloadKey != nil { + l = m.PayloadKey.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.Commitment != nil { + l = m.Commitment.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *ActionPlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *NullifierWithNote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Nullifier != nil { + l = m.Nullifier.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.Note != nil { + l = m.Note.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *ActionPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i +func (m *TransactionView) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if m.Action != nil { - { - size := m.Action.Size() - i -= size - if _, err := m.Action.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } + if m.BodyView != nil { + l = m.BodyView.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.BindingSig != nil { + l = m.BindingSig.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.Anchor != nil { + l = m.Anchor.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n +} + +func (m *TransactionBodyView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ActionViews) > 0 { + for _, e := range m.ActionViews { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } } - return len(dAtA) - i, nil + if m.TransactionParameters != nil { + l = m.TransactionParameters.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.DetectionData != nil { + l = m.DetectionData.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.MemoView != nil { + l = m.MemoView.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *ActionPlan_Spend) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *ActionView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ActionView != nil { + n += m.ActionView.Size() + } + return n } -func (m *ActionPlan_Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_Spend) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.Spend != nil { - { - size, err := m.Spend.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + l = m.Spend.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_Output) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_Output) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_Output) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.Output != nil { - { - size, err := m.Output.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + l = m.Output.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_Swap) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_Swap) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.Swap != nil { - { - size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a + l = m.Swap.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_SwapClaim) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_SwapClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.SwapClaim != nil { - { - size, err := m.SwapClaim.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 + l = m.SwapClaim.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_ValidatorDefinition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.ValidatorDefinition != nil { - { - size, err := m.ValidatorDefinition.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x82 + l = m.ValidatorDefinition.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_IbcAction) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_IbcAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.IbcAction != nil { - { - size, err := m.IbcAction.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x8a +func (m *ActionView_IbcRelayAction) Size() (n int) { + if m == nil { + return 0 } - return len(dAtA) - i, nil -} -func (m *ActionPlan_ProposalSubmit) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + var l int + _ = l + if m.IbcRelayAction != nil { + l = m.IbcRelayAction.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *ActionPlan_ProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_ProposalSubmit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.ProposalSubmit != nil { - { - size, err := m.ProposalSubmit.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x92 + l = m.ProposalSubmit.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_ProposalWithdraw) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_ProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_ProposalWithdraw) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.ProposalWithdraw != nil { - { - size, err := m.ProposalWithdraw.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x9a + l = m.ProposalWithdraw.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_ValidatorVote) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_ValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_ValidatorVote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.ValidatorVote != nil { - { - size, err := m.ValidatorVote.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa2 + l = m.ValidatorVote.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_DelegatorVote) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_DelegatorVote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.DelegatorVote != nil { - { - size, err := m.DelegatorVote.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xaa + l = m.DelegatorVote.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_ProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_ProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_ProposalDepositClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.ProposalDepositClaim != nil { - { - size, err := m.ProposalDepositClaim.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xb2 + l = m.ProposalDepositClaim.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_Withdrawal) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Withdrawal != nil { - { - size, err := m.Withdrawal.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xba +func (m *ActionView_PositionOpen) Size() (n int) { + if m == nil { + return 0 } - return len(dAtA) - i, nil + var l int + _ = l + if m.PositionOpen != nil { + l = m.PositionOpen.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } -func (m *ActionPlan_PositionOpen) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *ActionView_PositionClose) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PositionClose != nil { + l = m.PositionClose.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *ActionPlan_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.PositionOpen != nil { - { - size, err := m.PositionOpen.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xf2 - } - return len(dAtA) - i, nil -} -func (m *ActionPlan_PositionClose) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ActionPlan_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.PositionClose != nil { - { - size, err := m.PositionClose.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xfa +func (m *ActionView_PositionWithdraw) Size() (n int) { + if m == nil { + return 0 } - return len(dAtA) - i, nil -} -func (m *ActionPlan_PositionWithdraw) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ActionPlan_PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) + var l int + _ = l if m.PositionWithdraw != nil { - { - size, err := m.PositionWithdraw.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2 - i-- - dAtA[i] = 0x82 + l = m.PositionWithdraw.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_PositionRewardClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_PositionRewardClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.PositionRewardClaim != nil { - { - size, err := m.PositionRewardClaim.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2 - i-- - dAtA[i] = 0x92 + l = m.PositionRewardClaim.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_Delegate) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_Delegate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.Delegate != nil { - { - size, err := m.Delegate.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2 - i-- - dAtA[i] = 0xc2 + l = m.Delegate.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_Undelegate) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_Undelegate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.Undelegate != nil { - { - size, err := m.Undelegate.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2 - i-- - dAtA[i] = 0xca + l = m.Undelegate.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_UndelegateClaim) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) +func (m *ActionView_UndelegateClaim) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l if m.UndelegateClaim != nil { - { - size, err := m.UndelegateClaim.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2 - i-- - dAtA[i] = 0xd2 + l = m.UndelegateClaim.Size() + n += 2 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil -} -func (m *ActionPlan_DaoSpend) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } - -func (m *ActionPlan_DaoSpend) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.DaoSpend != nil { - { - size, err := m.DaoSpend.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3 - i-- - dAtA[i] = 0x92 +func (m *ActionView_CommunityPoolSpend) Size() (n int) { + if m == nil { + return 0 } - return len(dAtA) - i, nil + var l int + _ = l + if m.CommunityPoolSpend != nil { + l = m.CommunityPoolSpend.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } -func (m *ActionPlan_DaoOutput) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *ActionView_CommunityPoolOutput) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CommunityPoolOutput != nil { + l = m.CommunityPoolOutput.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *ActionPlan_DaoOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.DaoOutput != nil { - { - size, err := m.DaoOutput.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3 - i-- - dAtA[i] = 0x9a +func (m *ActionView_CommunityPoolDeposit) Size() (n int) { + if m == nil { + return 0 } - return len(dAtA) - i, nil + var l int + _ = l + if m.CommunityPoolDeposit != nil { + l = m.CommunityPoolDeposit.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } -func (m *ActionPlan_DaoDeposit) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *ActionView_Ics20Withdrawal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Ics20Withdrawal != nil { + l = m.Ics20Withdrawal.Size() + n += 2 + l + sovTransaction(uint64(l)) + } + return n } - -func (m *ActionPlan_DaoDeposit) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.DaoDeposit != nil { - { - size, err := m.DaoDeposit.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3 - i-- - dAtA[i] = 0xa2 - } - return len(dAtA) - i, nil -} -func (m *CluePlan) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *AuthorizationData) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *CluePlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *CluePlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if m.PrecisionBits != 0 { - i = encodeVarintTransaction(dAtA, i, uint64(m.PrecisionBits)) - i-- - dAtA[i] = 0x18 + if m.EffectHash != nil { + l = m.EffectHash.Size() + n += 1 + l + sovTransaction(uint64(l)) } - if len(m.Rseed) > 0 { - i -= len(m.Rseed) - copy(dAtA[i:], m.Rseed) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Rseed))) - i-- - dAtA[i] = 0x12 + if len(m.SpendAuths) > 0 { + for _, e := range m.SpendAuths { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) + } } - if m.Address != nil { - { - size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) + if len(m.DelegatorVoteAuths) > 0 { + for _, e := range m.DelegatorVoteAuths { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } - i-- - dAtA[i] = 0xa } - return len(dAtA) - i, nil + return n } -func (m *MemoPlan) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *WitnessData) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *MemoPlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MemoPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if len(m.Key) > 0 { - i -= len(m.Key) - copy(dAtA[i:], m.Key) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Key))) - i-- - dAtA[i] = 0x12 + if m.Anchor != nil { + l = m.Anchor.Size() + n += 1 + l + sovTransaction(uint64(l)) } - if m.Plaintext != nil { - { - size, err := m.Plaintext.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) + if len(m.StateCommitmentProofs) > 0 { + for _, e := range m.StateCommitmentProofs { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } - i-- - dAtA[i] = 0xa } - return len(dAtA) - i, nil + return n } -func (m *MemoCiphertext) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *TransactionPlan) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *MemoCiphertext) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MemoCiphertext) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Inner))) - i-- - dAtA[i] = 0xa + if len(m.Actions) > 0 { + for _, e := range m.Actions { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) + } } - return len(dAtA) - i, nil -} - -func (m *MemoPlaintext) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + if m.TransactionParameters != nil { + l = m.TransactionParameters.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return dAtA[:n], nil -} - -func (m *MemoPlaintext) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if m.DetectionData != nil { + l = m.DetectionData.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.Memo != nil { + l = m.Memo.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *MemoPlaintext) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i +func (m *DetectionDataPlan) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.Text) > 0 { - i -= len(m.Text) - copy(dAtA[i:], m.Text) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Text))) - i-- - dAtA[i] = 0x12 - } - if m.Sender != nil { - { - size, err := m.Sender.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) + if len(m.CluePlans) > 0 { + for _, e := range m.CluePlans { + l = e.Size() + n += 1 + l + sovTransaction(uint64(l)) } - i-- - dAtA[i] = 0xa } - return len(dAtA) - i, nil + return n } -func (m *MemoView) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *ActionPlan) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *MemoView) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MemoView) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if m.MemoView != nil { - { - size := m.MemoView.Size() - i -= size - if _, err := m.MemoView.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } + if m.Action != nil { + n += m.Action.Size() } - return len(dAtA) - i, nil -} - -func (m *MemoView_Visible_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return n } -func (m *MemoView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Visible != nil { - { - size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa +func (m *ActionPlan_Spend) Size() (n int) { + if m == nil { + return 0 } - return len(dAtA) - i, nil + var l int + _ = l + if m.Spend != nil { + l = m.Spend.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *MemoView_Opaque_) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MemoView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Opaque != nil { - { - size, err := m.Opaque.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *MemoView_Visible) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *ActionPlan_Output) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *MemoView_Visible) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MemoView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if m.Plaintext != nil { - { - size, err := m.Plaintext.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Ciphertext != nil { - { - size, err := m.Ciphertext.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + if m.Output != nil { + l = m.Output.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil + return n } - -func (m *MemoView_Opaque) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *ActionPlan_Swap) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *MemoView_Opaque) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MemoView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if m.Ciphertext != nil { - { - size, err := m.Ciphertext.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + if m.Swap != nil { + l = m.Swap.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil + return n } - -func (m *SpendPlan) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *ActionPlan_SwapClaim) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SpendPlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SpendPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if len(m.ProofBlindingS) > 0 { - i -= len(m.ProofBlindingS) - copy(dAtA[i:], m.ProofBlindingS) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.ProofBlindingS))) - i-- - dAtA[i] = 0x32 - } - if len(m.ProofBlindingR) > 0 { - i -= len(m.ProofBlindingR) - copy(dAtA[i:], m.ProofBlindingR) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.ProofBlindingR))) - i-- - dAtA[i] = 0x2a - } - if len(m.ValueBlinding) > 0 { - i -= len(m.ValueBlinding) - copy(dAtA[i:], m.ValueBlinding) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.ValueBlinding))) - i-- - dAtA[i] = 0x22 - } - if len(m.Randomizer) > 0 { - i -= len(m.Randomizer) - copy(dAtA[i:], m.Randomizer) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Randomizer))) - i-- - dAtA[i] = 0x1a - } - if m.Position != 0 { - i = encodeVarintTransaction(dAtA, i, uint64(m.Position)) - i-- - dAtA[i] = 0x10 - } - if m.Note != nil { - { - size, err := m.Note.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + if m.SwapClaim != nil { + l = m.SwapClaim.Size() + n += 1 + l + sovTransaction(uint64(l)) } - return len(dAtA) - i, nil + return n } - -func (m *OutputPlan) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *ActionPlan_ValidatorDefinition) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *OutputPlan) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *OutputPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i var l int _ = l - if len(m.ProofBlindingS) > 0 { - i -= len(m.ProofBlindingS) - copy(dAtA[i:], m.ProofBlindingS) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.ProofBlindingS))) - i-- - dAtA[i] = 0x32 - } - if len(m.ProofBlindingR) > 0 { - i -= len(m.ProofBlindingR) - copy(dAtA[i:], m.ProofBlindingR) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.ProofBlindingR))) - i-- - dAtA[i] = 0x2a - } - if len(m.ValueBlinding) > 0 { - i -= len(m.ValueBlinding) - copy(dAtA[i:], m.ValueBlinding) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.ValueBlinding))) - i-- - dAtA[i] = 0x22 - } - if len(m.Rseed) > 0 { - i -= len(m.Rseed) - copy(dAtA[i:], m.Rseed) - i = encodeVarintTransaction(dAtA, i, uint64(len(m.Rseed))) - i-- - dAtA[i] = 0x1a - } - if m.DestAddress != nil { - { - size, err := m.DestAddress.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Value != nil { - { - size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransaction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func encodeVarintTransaction(dAtA []byte, offset int, v uint64) int { - offset -= sovTransaction(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ + if m.ValidatorDefinition != nil { + l = m.ValidatorDefinition.Size() + n += 2 + l + sovTransaction(uint64(l)) } - dAtA[offset] = uint8(v) - return base + return n } -func (m *Transaction) Size() (n int) { +func (m *ActionPlan_IbcRelayAction) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Body != nil { - l = m.Body.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.BindingSig) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Anchor != nil { - l = m.Anchor.Size() - n += 1 + l + sovTransaction(uint64(l)) + if m.IbcRelayAction != nil { + l = m.IbcRelayAction.Size() + n += 2 + l + sovTransaction(uint64(l)) } return n } - -func (m *Id) Size() (n int) { +func (m *ActionPlan_ProposalSubmit) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Hash) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) + if m.ProposalSubmit != nil { + l = m.ProposalSubmit.Size() + n += 2 + l + sovTransaction(uint64(l)) } return n } - -func (m *EffectHash) Size() (n int) { +func (m *ActionPlan_ProposalWithdraw) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) + if m.ProposalWithdraw != nil { + l = m.ProposalWithdraw.Size() + n += 2 + l + sovTransaction(uint64(l)) } return n } - -func (m *TransactionBody) Size() (n int) { +func (m *ActionPlan_ValidatorVote) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.Actions) > 0 { - for _, e := range m.Actions { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - if m.TransactionParameters != nil { - l = m.TransactionParameters.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Fee != nil { - l = m.Fee.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.DetectionData != nil { - l = m.DetectionData.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.MemoData != nil { - l = m.MemoData.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *MemoData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XEncryptedMemo != nil { - n += m.XEncryptedMemo.Size() - } - return n -} - -func (m *MemoData_EncryptedMemo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.EncryptedMemo != nil { - l = len(m.EncryptedMemo) - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *TransactionParameters) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ExpiryHeight != 0 { - n += 1 + sovTransaction(uint64(m.ExpiryHeight)) - } - l = len(m.ChainId) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *DetectionData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.FmdClues) > 0 { - for _, e := range m.FmdClues { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - return n -} - -func (m *Action) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Action != nil { - n += m.Action.Size() - } - return n -} - -func (m *Action_Spend) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Spend != nil { - l = m.Spend.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *Action_Output) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Output != nil { - l = m.Output.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *Action_Swap) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Swap != nil { - l = m.Swap.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *Action_SwapClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapClaim != nil { - l = m.SwapClaim.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *Action_ValidatorDefinition) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ValidatorDefinition != nil { - l = m.ValidatorDefinition.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *Action_IbcAction) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.IbcAction != nil { - l = m.IbcAction.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *Action_ProposalSubmit) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ProposalSubmit != nil { - l = m.ProposalSubmit.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *Action_ProposalWithdraw) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ProposalWithdraw != nil { - l = m.ProposalWithdraw.Size() + if m.ValidatorVote != nil { + l = m.ValidatorVote.Size() n += 2 + l + sovTransaction(uint64(l)) } return n } -func (m *Action_ValidatorVote) Size() (n int) { +func (m *ActionPlan_DelegatorVote) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.ValidatorVote != nil { - l = m.ValidatorVote.Size() + if m.DelegatorVote != nil { + l = m.DelegatorVote.Size() n += 2 + l + sovTransaction(uint64(l)) } return n } -func (m *Action_DelegatorVote) Size() (n int) { +func (m *ActionPlan_ProposalDepositClaim) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.DelegatorVote != nil { - l = m.DelegatorVote.Size() + if m.ProposalDepositClaim != nil { + l = m.ProposalDepositClaim.Size() n += 2 + l + sovTransaction(uint64(l)) } return n } -func (m *Action_ProposalDepositClaim) Size() (n int) { +func (m *ActionPlan_Withdrawal) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.ProposalDepositClaim != nil { - l = m.ProposalDepositClaim.Size() + if m.Withdrawal != nil { + l = m.Withdrawal.Size() n += 2 + l + sovTransaction(uint64(l)) } return n } -func (m *Action_PositionOpen) Size() (n int) { +func (m *ActionPlan_PositionOpen) Size() (n int) { if m == nil { return 0 } @@ -7713,7 +6290,7 @@ func (m *Action_PositionOpen) Size() (n int) { } return n } -func (m *Action_PositionClose) Size() (n int) { +func (m *ActionPlan_PositionClose) Size() (n int) { if m == nil { return 0 } @@ -7725,7 +6302,7 @@ func (m *Action_PositionClose) Size() (n int) { } return n } -func (m *Action_PositionWithdraw) Size() (n int) { +func (m *ActionPlan_PositionWithdraw) Size() (n int) { if m == nil { return 0 } @@ -7737,7 +6314,7 @@ func (m *Action_PositionWithdraw) Size() (n int) { } return n } -func (m *Action_PositionRewardClaim) Size() (n int) { +func (m *ActionPlan_PositionRewardClaim) Size() (n int) { if m == nil { return 0 } @@ -7749,7 +6326,7 @@ func (m *Action_PositionRewardClaim) Size() (n int) { } return n } -func (m *Action_Delegate) Size() (n int) { +func (m *ActionPlan_Delegate) Size() (n int) { if m == nil { return 0 } @@ -7761,7 +6338,7 @@ func (m *Action_Delegate) Size() (n int) { } return n } -func (m *Action_Undelegate) Size() (n int) { +func (m *ActionPlan_Undelegate) Size() (n int) { if m == nil { return 0 } @@ -7773,7 +6350,7 @@ func (m *Action_Undelegate) Size() (n int) { } return n } -func (m *Action_UndelegateClaim) Size() (n int) { +func (m *ActionPlan_UndelegateClaim) Size() (n int) { if m == nil { return 0 } @@ -7785,100 +6362,82 @@ func (m *Action_UndelegateClaim) Size() (n int) { } return n } -func (m *Action_DaoSpend) Size() (n int) { +func (m *ActionPlan_CommunityPoolSpend) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.DaoSpend != nil { - l = m.DaoSpend.Size() + if m.CommunityPoolSpend != nil { + l = m.CommunityPoolSpend.Size() n += 2 + l + sovTransaction(uint64(l)) } return n } -func (m *Action_DaoOutput) Size() (n int) { +func (m *ActionPlan_CommunityPoolOutput) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.DaoOutput != nil { - l = m.DaoOutput.Size() + if m.CommunityPoolOutput != nil { + l = m.CommunityPoolOutput.Size() n += 2 + l + sovTransaction(uint64(l)) } return n } -func (m *Action_DaoDeposit) Size() (n int) { +func (m *ActionPlan_CommunityPoolDeposit) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.DaoDeposit != nil { - l = m.DaoDeposit.Size() + if m.CommunityPoolDeposit != nil { + l = m.CommunityPoolDeposit.Size() n += 2 + l + sovTransaction(uint64(l)) } return n } -func (m *Action_Ics20Withdrawal) Size() (n int) { +func (m *CluePlan) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Ics20Withdrawal != nil { - l = m.Ics20Withdrawal.Size() - n += 2 + l + sovTransaction(uint64(l)) + if m.Address != nil { + l = m.Address.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + l = len(m.Rseed) + if l > 0 { + n += 1 + l + sovTransaction(uint64(l)) + } + if m.PrecisionBits != 0 { + n += 1 + sovTransaction(uint64(m.PrecisionBits)) } return n } -func (m *TransactionPerspective) Size() (n int) { + +func (m *MemoPlan) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.PayloadKeys) > 0 { - for _, e := range m.PayloadKeys { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - if len(m.SpendNullifiers) > 0 { - for _, e := range m.SpendNullifiers { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } + if m.Plaintext != nil { + l = m.Plaintext.Size() + n += 1 + l + sovTransaction(uint64(l)) } - if len(m.AdviceNotes) > 0 { - for _, e := range m.AdviceNotes { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovTransaction(uint64(l)) } - if len(m.AddressViews) > 0 { - for _, e := range m.AddressViews { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - if len(m.Denoms) > 0 { - for _, e := range m.Denoms { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - if m.TransactionId != nil { - l = m.TransactionId.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *PayloadKey) Size() (n int) { - if m == nil { - return 0 + return n +} + +func (m *MemoCiphertext) Size() (n int) { + if m == nil { + return 0 } var l int _ = l @@ -7889,3217 +6448,113 @@ func (m *PayloadKey) Size() (n int) { return n } -func (m *PayloadKeyWithCommitment) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PayloadKey != nil { - l = m.PayloadKey.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Commitment != nil { - l = m.Commitment.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *NullifierWithNote) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Nullifier != nil { - l = m.Nullifier.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Note != nil { - l = m.Note.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *TransactionView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.BodyView != nil { - l = m.BodyView.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.BindingSig) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Anchor != nil { - l = m.Anchor.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *TransactionBodyView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.ActionViews) > 0 { - for _, e := range m.ActionViews { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - if m.TransactionParameters != nil { - l = m.TransactionParameters.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Fee != nil { - l = m.Fee.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.XDetectionData != nil { - n += m.XDetectionData.Size() - } - if m.XMemoView != nil { - n += m.XMemoView.Size() - } - return n -} - -func (m *TransactionBodyView_DetectionData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DetectionData != nil { - l = m.DetectionData.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *TransactionBodyView_MemoView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.MemoView != nil { - l = m.MemoView.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ActionView != nil { - n += m.ActionView.Size() - } - return n -} - -func (m *ActionView_Spend) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Spend != nil { - l = m.Spend.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_Output) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Output != nil { - l = m.Output.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_Swap) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Swap != nil { - l = m.Swap.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_SwapClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapClaim != nil { - l = m.SwapClaim.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_ValidatorDefinition) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ValidatorDefinition != nil { - l = m.ValidatorDefinition.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_IbcAction) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.IbcAction != nil { - l = m.IbcAction.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_ProposalSubmit) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ProposalSubmit != nil { - l = m.ProposalSubmit.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_ProposalWithdraw) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ProposalWithdraw != nil { - l = m.ProposalWithdraw.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_ValidatorVote) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ValidatorVote != nil { - l = m.ValidatorVote.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_DelegatorVote) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DelegatorVote != nil { - l = m.DelegatorVote.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_ProposalDepositClaim) Size() (n int) { +func (m *MemoPlaintext) Size() (n int) { if m == nil { return 0 } var l int - _ = l - if m.ProposalDepositClaim != nil { - l = m.ProposalDepositClaim.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_PositionOpen) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionOpen != nil { - l = m.PositionOpen.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_PositionClose) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionClose != nil { - l = m.PositionClose.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_PositionWithdraw) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionWithdraw != nil { - l = m.PositionWithdraw.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_PositionRewardClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionRewardClaim != nil { - l = m.PositionRewardClaim.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_Delegate) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Delegate != nil { - l = m.Delegate.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_Undelegate) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Undelegate != nil { - l = m.Undelegate.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_UndelegateClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.UndelegateClaim != nil { - l = m.UndelegateClaim.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_DaoSpend) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DaoSpend != nil { - l = m.DaoSpend.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_DaoOutput) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DaoOutput != nil { - l = m.DaoOutput.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_DaoDeposit) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DaoDeposit != nil { - l = m.DaoDeposit.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionView_Ics20Withdrawal) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Ics20Withdrawal != nil { - l = m.Ics20Withdrawal.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *SpendView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SpendView != nil { - n += m.SpendView.Size() - } - return n -} - -func (m *SpendView_Visible_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Visible != nil { - l = m.Visible.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *SpendView_Opaque_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Opaque != nil { - l = m.Opaque.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *SpendView_Visible) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Spend != nil { - l = m.Spend.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Note != nil { - l = m.Note.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *SpendView_Opaque) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Spend != nil { - l = m.Spend.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *DelegatorVoteView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DelegatorVote != nil { - n += m.DelegatorVote.Size() - } - return n -} - -func (m *DelegatorVoteView_Visible_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Visible != nil { - l = m.Visible.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *DelegatorVoteView_Opaque_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Opaque != nil { - l = m.Opaque.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *DelegatorVoteView_Visible) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DelegatorVote != nil { - l = m.DelegatorVote.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Note != nil { - l = m.Note.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *DelegatorVoteView_Opaque) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DelegatorVote != nil { - l = m.DelegatorVote.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *OutputView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.OutputView != nil { - n += m.OutputView.Size() - } - return n -} - -func (m *OutputView_Visible_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Visible != nil { - l = m.Visible.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *OutputView_Opaque_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Opaque != nil { - l = m.Opaque.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *OutputView_Visible) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Output != nil { - l = m.Output.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Note != nil { - l = m.Note.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.PayloadKey != nil { - l = m.PayloadKey.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *OutputView_Opaque) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Output != nil { - l = m.Output.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *Spend) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Body != nil { - l = m.Body.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.AuthSig != nil { - l = m.AuthSig.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Proof != nil { - l = m.Proof.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *SpendBody) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.BalanceCommitment != nil { - l = m.BalanceCommitment.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.Nullifier) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.Rk) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *Output) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Body != nil { - l = m.Body.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Proof != nil { - l = m.Proof.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *OutputBody) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.NotePayload != nil { - l = m.NotePayload.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.BalanceCommitment != nil { - l = m.BalanceCommitment.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.WrappedMemoKey) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.OvkWrappedKey) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *AuthorizationData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.EffectHash != nil { - l = m.EffectHash.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if len(m.SpendAuths) > 0 { - for _, e := range m.SpendAuths { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - if len(m.DelegatorVoteAuths) > 0 { - for _, e := range m.DelegatorVoteAuths { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - return n -} - -func (m *WitnessData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Anchor != nil { - l = m.Anchor.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if len(m.StateCommitmentProofs) > 0 { - for _, e := range m.StateCommitmentProofs { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - return n -} - -func (m *TransactionPlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Actions) > 0 { - for _, e := range m.Actions { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - if m.ExpiryHeight != 0 { - n += 1 + sovTransaction(uint64(m.ExpiryHeight)) - } - l = len(m.ChainId) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Fee != nil { - l = m.Fee.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if len(m.CluePlans) > 0 { - for _, e := range m.CluePlans { - l = e.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - } - if m.MemoPlan != nil { - l = m.MemoPlan.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *ActionPlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Action != nil { - n += m.Action.Size() - } - return n -} - -func (m *ActionPlan_Spend) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Spend != nil { - l = m.Spend.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_Output) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Output != nil { - l = m.Output.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_Swap) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Swap != nil { - l = m.Swap.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_SwapClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapClaim != nil { - l = m.SwapClaim.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_ValidatorDefinition) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ValidatorDefinition != nil { - l = m.ValidatorDefinition.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_IbcAction) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.IbcAction != nil { - l = m.IbcAction.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_ProposalSubmit) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ProposalSubmit != nil { - l = m.ProposalSubmit.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_ProposalWithdraw) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ProposalWithdraw != nil { - l = m.ProposalWithdraw.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_ValidatorVote) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ValidatorVote != nil { - l = m.ValidatorVote.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_DelegatorVote) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DelegatorVote != nil { - l = m.DelegatorVote.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_ProposalDepositClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ProposalDepositClaim != nil { - l = m.ProposalDepositClaim.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_Withdrawal) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Withdrawal != nil { - l = m.Withdrawal.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_PositionOpen) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionOpen != nil { - l = m.PositionOpen.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_PositionClose) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionClose != nil { - l = m.PositionClose.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_PositionWithdraw) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionWithdraw != nil { - l = m.PositionWithdraw.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_PositionRewardClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PositionRewardClaim != nil { - l = m.PositionRewardClaim.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_Delegate) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Delegate != nil { - l = m.Delegate.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_Undelegate) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Undelegate != nil { - l = m.Undelegate.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_UndelegateClaim) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.UndelegateClaim != nil { - l = m.UndelegateClaim.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_DaoSpend) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DaoSpend != nil { - l = m.DaoSpend.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_DaoOutput) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DaoOutput != nil { - l = m.DaoOutput.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *ActionPlan_DaoDeposit) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DaoDeposit != nil { - l = m.DaoDeposit.Size() - n += 2 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *CluePlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Address != nil { - l = m.Address.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.Rseed) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - if m.PrecisionBits != 0 { - n += 1 + sovTransaction(uint64(m.PrecisionBits)) - } - return n -} - -func (m *MemoPlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Plaintext != nil { - l = m.Plaintext.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.Key) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *MemoCiphertext) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Inner) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *MemoPlaintext) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Sender != nil { - l = m.Sender.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.Text) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *MemoView) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.MemoView != nil { - n += m.MemoView.Size() - } - return n -} - -func (m *MemoView_Visible_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Visible != nil { - l = m.Visible.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *MemoView_Opaque_) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Opaque != nil { - l = m.Opaque.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} -func (m *MemoView_Visible) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Ciphertext != nil { - l = m.Ciphertext.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Plaintext != nil { - l = m.Plaintext.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *MemoView_Opaque) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Ciphertext != nil { - l = m.Ciphertext.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *SpendPlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Note != nil { - l = m.Note.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.Position != 0 { - n += 1 + sovTransaction(uint64(m.Position)) - } - l = len(m.Randomizer) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.ValueBlinding) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.ProofBlindingR) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.ProofBlindingS) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func (m *OutputPlan) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != nil { - l = m.Value.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - if m.DestAddress != nil { - l = m.DestAddress.Size() - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.Rseed) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.ValueBlinding) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.ProofBlindingR) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - l = len(m.ProofBlindingS) - if l > 0 { - n += 1 + l + sovTransaction(uint64(l)) - } - return n -} - -func sovTransaction(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozTransaction(x uint64) (n int) { - return sovTransaction(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *Transaction) 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 ErrIntOverflowTransaction - } - 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: Transaction: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Transaction: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Body == nil { - m.Body = &TransactionBody{} - } - if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BindingSig", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.BindingSig = append(m.BindingSig[:0], dAtA[iNdEx:postIndex]...) - if m.BindingSig == nil { - m.BindingSig = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Anchor", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Anchor == nil { - m.Anchor = &v1alpha1.MerkleRoot{} - } - if err := m.Anchor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Id) 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 ErrIntOverflowTransaction - } - 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: Id: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Id: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) - if m.Hash == nil { - m.Hash = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *EffectHash) 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 ErrIntOverflowTransaction - } - 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: EffectHash: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: EffectHash: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TransactionBody) 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 ErrIntOverflowTransaction - } - 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: TransactionBody: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TransactionBody: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Actions = append(m.Actions, &Action{}) - if err := m.Actions[len(m.Actions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TransactionParameters", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.TransactionParameters == nil { - m.TransactionParameters = &TransactionParameters{} - } - if err := m.TransactionParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Fee == nil { - m.Fee = &v1alpha1.Fee{} - } - if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DetectionData", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.DetectionData == nil { - m.DetectionData = &DetectionData{} - } - if err := m.DetectionData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MemoData", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.MemoData == nil { - m.MemoData = &MemoData{} - } - if err := m.MemoData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MemoData) 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 ErrIntOverflowTransaction - } - 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: MemoData: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MemoData: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EncryptedMemo", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := make([]byte, postIndex-iNdEx) - copy(v, dAtA[iNdEx:postIndex]) - m.XEncryptedMemo = &MemoData_EncryptedMemo{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TransactionParameters) 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 ErrIntOverflowTransaction - } - 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: TransactionParameters: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TransactionParameters: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ExpiryHeight", wireType) - } - m.ExpiryHeight = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ExpiryHeight |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - 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 ErrInvalidLengthTransaction - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ChainId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DetectionData) 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 ErrIntOverflowTransaction - } - 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: DetectionData: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DetectionData: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FmdClues", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.FmdClues = append(m.FmdClues, &v1alpha1.Clue{}) - if err := m.FmdClues[len(m.FmdClues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Action) 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 ErrIntOverflowTransaction - } - 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: Action: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Action: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &Spend{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_Spend{v} - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &Output{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_Output{v} - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.Swap{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_Swap{v} - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.SwapClaim{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_SwapClaim{v} - iNdEx = postIndex - case 16: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDefinition", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha12.ValidatorDefinition{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_ValidatorDefinition{v} - iNdEx = postIndex - case 17: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IbcAction", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha13.IbcAction{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_IbcAction{v} - iNdEx = postIndex - case 18: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalSubmit", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha14.ProposalSubmit{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_ProposalSubmit{v} - iNdEx = postIndex - case 19: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalWithdraw", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha14.ProposalWithdraw{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_ProposalWithdraw{v} - iNdEx = postIndex - case 20: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorVote", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha14.ValidatorVote{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_ValidatorVote{v} - iNdEx = postIndex - case 21: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha14.DelegatorVote{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_DelegatorVote{v} - iNdEx = postIndex - case 22: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositClaim", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha14.ProposalDepositClaim{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_ProposalDepositClaim{v} - iNdEx = postIndex - case 30: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionOpen", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.PositionOpen{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_PositionOpen{v} - iNdEx = postIndex - case 31: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionClose", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.PositionClose{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_PositionClose{v} - iNdEx = postIndex - case 32: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionWithdraw", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.PositionWithdraw{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_PositionWithdraw{v} - iNdEx = postIndex - case 34: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionRewardClaim", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.PositionRewardClaim{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_PositionRewardClaim{v} - iNdEx = postIndex - case 40: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Delegate", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha12.Delegate{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_Delegate{v} - iNdEx = postIndex - case 41: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Undelegate", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha12.Undelegate{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_Undelegate{v} - iNdEx = postIndex - case 42: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha12.UndelegateClaim{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_UndelegateClaim{v} - iNdEx = postIndex - case 50: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoSpend", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha14.DaoSpend{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_DaoSpend{v} - iNdEx = postIndex - case 51: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoOutput", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha14.DaoOutput{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_DaoOutput{v} - iNdEx = postIndex - case 52: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoDeposit", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha14.DaoDeposit{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_DaoDeposit{v} - iNdEx = postIndex - case 200: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ics20Withdrawal", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha13.Ics20Withdrawal{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &Action_Ics20Withdrawal{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TransactionPerspective) 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 ErrIntOverflowTransaction - } - 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: TransactionPerspective: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TransactionPerspective: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PayloadKeys", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.PayloadKeys = append(m.PayloadKeys, &PayloadKeyWithCommitment{}) - if err := m.PayloadKeys[len(m.PayloadKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SpendNullifiers", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SpendNullifiers = append(m.SpendNullifiers, &NullifierWithNote{}) - if err := m.SpendNullifiers[len(m.SpendNullifiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AdviceNotes", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.AdviceNotes = append(m.AdviceNotes, &v1alpha1.Note{}) - if err := m.AdviceNotes[len(m.AdviceNotes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AddressViews", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.AddressViews = append(m.AddressViews, &v1alpha1.AddressView{}) - if err := m.AddressViews[len(m.AddressViews)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Denoms", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Denoms = append(m.Denoms, &v1alpha1.DenomMetadata{}) - if err := m.Denoms[len(m.Denoms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.TransactionId == nil { - m.TransactionId = &Id{} - } - if err := m.TransactionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } + _ = l + if m.ReturnAddress != nil { + l = m.ReturnAddress.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + l = len(m.Text) + if l > 0 { + n += 1 + l + sovTransaction(uint64(l)) } + return n +} - if iNdEx > l { - return io.ErrUnexpectedEOF +func (m *MemoPlaintextView) Size() (n int) { + if m == nil { + return 0 } - return nil + var l int + _ = l + if m.ReturnAddress != nil { + l = m.ReturnAddress.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + l = len(m.Text) + if l > 0 { + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *PayloadKey) 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 ErrIntOverflowTransaction - } - 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: PayloadKey: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PayloadKey: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } + +func (m *MemoView) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MemoView != nil { + n += m.MemoView.Size() } + return n +} - if iNdEx > l { - return io.ErrUnexpectedEOF +func (m *MemoView_Visible_) Size() (n int) { + if m == nil { + return 0 } - return nil + var l int + _ = l + if m.Visible != nil { + l = m.Visible.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n } -func (m *PayloadKeyWithCommitment) Unmarshal(dAtA []byte) error { +func (m *MemoView_Opaque_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Opaque != nil { + l = m.Opaque.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n +} +func (m *MemoView_Visible) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Ciphertext != nil { + l = m.Ciphertext.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + if m.Plaintext != nil { + l = m.Plaintext.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n +} + +func (m *MemoView_Opaque) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Ciphertext != nil { + l = m.Ciphertext.Size() + n += 1 + l + sovTransaction(uint64(l)) + } + return n +} + +func sovTransaction(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTransaction(x uint64) (n int) { + return sovTransaction(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Transaction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11122,51 +6577,15 @@ func (m *PayloadKeyWithCommitment) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PayloadKeyWithCommitment: wiretype end group for non-group") + return fmt.Errorf("proto: Transaction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PayloadKeyWithCommitment: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Transaction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PayloadKey", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.PayloadKey == nil { - m.PayloadKey = &PayloadKey{} - } - if err := m.PayloadKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Commitment", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11184,75 +6603,25 @@ func (m *PayloadKeyWithCommitment) Unmarshal(dAtA []byte) error { } } if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Commitment == nil { - m.Commitment = &v1alpha1.StateCommitment{} - } - if err := m.Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *NullifierWithNote) 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 ErrIntOverflowTransaction + return ErrInvalidLengthTransaction } - if iNdEx >= l { + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTransaction + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.Body == nil { + m.Body = &TransactionBody{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: NullifierWithNote: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: NullifierWithNote: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BindingSig", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11279,16 +6648,16 @@ func (m *NullifierWithNote) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Nullifier == nil { - m.Nullifier = &v1alpha1.Nullifier{} + if m.BindingSig == nil { + m.BindingSig = &v1alpha1.BindingSignature{} } - if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.BindingSig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Anchor", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11315,10 +6684,10 @@ func (m *NullifierWithNote) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Note == nil { - m.Note = &v1alpha1.Note{} + if m.Anchor == nil { + m.Anchor = &v1alpha11.MerkleRoot{} } - if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Anchor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -11343,7 +6712,7 @@ func (m *NullifierWithNote) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransactionView) Unmarshal(dAtA []byte) error { +func (m *TransactionBody) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11366,15 +6735,15 @@ func (m *TransactionView) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TransactionView: wiretype end group for non-group") + return fmt.Errorf("proto: TransactionBody: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TransactionView: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TransactionBody: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BodyView", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11401,18 +6770,16 @@ func (m *TransactionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.BodyView == nil { - m.BodyView = &TransactionBodyView{} - } - if err := m.BodyView.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Actions = append(m.Actions, &Action{}) + if err := m.Actions[len(m.Actions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BindingSig", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TransactionParameters", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -11422,29 +6789,31 @@ func (m *TransactionView) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.BindingSig = append(m.BindingSig[:0], dAtA[iNdEx:postIndex]...) - if m.BindingSig == nil { - m.BindingSig = []byte{} + if m.TransactionParameters == nil { + m.TransactionParameters = &TransactionParameters{} + } + if err := m.TransactionParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Anchor", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DetectionData", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11471,10 +6840,46 @@ func (m *TransactionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Anchor == nil { - m.Anchor = &v1alpha1.MerkleRoot{} + if m.DetectionData == nil { + m.DetectionData = &DetectionData{} } - if err := m.Anchor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.DetectionData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Memo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTransaction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTransaction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTransaction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Memo == nil { + m.Memo = &MemoCiphertext{} + } + if err := m.Memo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -11499,7 +6904,7 @@ func (m *TransactionView) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransactionBodyView) Unmarshal(dAtA []byte) error { +func (m *TransactionParameters) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11522,17 +6927,17 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TransactionBodyView: wiretype end group for non-group") + return fmt.Errorf("proto: TransactionParameters: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TransactionBodyView: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TransactionParameters: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ActionViews", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpiryHeight", wireType) } - var msglen int + m.ExpiryHeight = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -11542,31 +6947,16 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.ExpiryHeight |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ActionViews = append(m.ActionViews, &ActionView{}) - if err := m.ActionViews[len(m.ActionViews)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TransactionParameters", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -11576,27 +6966,23 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - if m.TransactionParameters == nil { - m.TransactionParameters = &TransactionParameters{} - } - if err := m.TransactionParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.ChainId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { @@ -11628,50 +7014,65 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Fee == nil { - m.Fee = &v1alpha1.Fee{} + m.Fee = &v1alpha12.Fee{} } if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DetectionData", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } + default: + iNdEx = preIndex + skippy, err := skipTransaction(dAtA[iNdEx:]) + if err != nil { + return err } - if msglen < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - if postIndex > l { + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DetectionData) 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 ErrIntOverflowTransaction + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - v := &DetectionData{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - m.XDetectionData = &TransactionBodyView_DetectionData{v} - iNdEx = postIndex - case 5: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DetectionData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DetectionData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MemoView", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field FmdClues", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11698,11 +7099,10 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &MemoView{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.FmdClues = append(m.FmdClues, &v1alpha13.Clue{}) + if err := m.FmdClues[len(m.FmdClues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.XMemoView = &TransactionBodyView_MemoView{v} iNdEx = postIndex default: iNdEx = preIndex @@ -11725,7 +7125,7 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error { } return nil } -func (m *ActionView) Unmarshal(dAtA []byte) error { +func (m *Action) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11748,10 +7148,10 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ActionView: wiretype end group for non-group") + return fmt.Errorf("proto: Action: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ActionView: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Action: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -11783,11 +7183,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &SpendView{} + v := &v1alpha14.Spend{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_Spend{v} + m.Action = &Action_Spend{v} iNdEx = postIndex case 2: if wireType != 2 { @@ -11818,11 +7218,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &OutputView{} + v := &v1alpha14.Output{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_Output{v} + m.Action = &Action_Output{v} iNdEx = postIndex case 3: if wireType != 2 { @@ -11853,11 +7253,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.SwapView{} + v := &v1alpha15.Swap{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_Swap{v} + m.Action = &Action_Swap{v} iNdEx = postIndex case 4: if wireType != 2 { @@ -11888,11 +7288,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.SwapClaimView{} + v := &v1alpha15.SwapClaim{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_SwapClaim{v} + m.Action = &Action_SwapClaim{v} iNdEx = postIndex case 16: if wireType != 2 { @@ -11923,15 +7323,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha12.ValidatorDefinition{} + v := &v1alpha16.ValidatorDefinition{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_ValidatorDefinition{v} + m.Action = &Action_ValidatorDefinition{v} iNdEx = postIndex case 17: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IbcAction", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IbcRelayAction", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11958,11 +7358,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha13.IbcAction{} + v := &v1alpha17.IbcRelay{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_IbcAction{v} + m.Action = &Action_IbcRelayAction{v} iNdEx = postIndex case 18: if wireType != 2 { @@ -11993,11 +7393,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.ProposalSubmit{} + v := &v1alpha18.ProposalSubmit{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_ProposalSubmit{v} + m.Action = &Action_ProposalSubmit{v} iNdEx = postIndex case 19: if wireType != 2 { @@ -12028,11 +7428,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.ProposalWithdraw{} + v := &v1alpha18.ProposalWithdraw{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_ProposalWithdraw{v} + m.Action = &Action_ProposalWithdraw{v} iNdEx = postIndex case 20: if wireType != 2 { @@ -12063,11 +7463,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.ValidatorVote{} + v := &v1alpha18.ValidatorVote{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_ValidatorVote{v} + m.Action = &Action_ValidatorVote{v} iNdEx = postIndex case 21: if wireType != 2 { @@ -12098,11 +7498,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &DelegatorVoteView{} + v := &v1alpha18.DelegatorVote{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_DelegatorVote{v} + m.Action = &Action_DelegatorVote{v} iNdEx = postIndex case 22: if wireType != 2 { @@ -12133,11 +7533,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.ProposalDepositClaim{} + v := &v1alpha18.ProposalDepositClaim{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_ProposalDepositClaim{v} + m.Action = &Action_ProposalDepositClaim{v} iNdEx = postIndex case 30: if wireType != 2 { @@ -12168,11 +7568,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.PositionOpen{} + v := &v1alpha15.PositionOpen{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_PositionOpen{v} + m.Action = &Action_PositionOpen{v} iNdEx = postIndex case 31: if wireType != 2 { @@ -12203,11 +7603,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.PositionClose{} + v := &v1alpha15.PositionClose{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_PositionClose{v} + m.Action = &Action_PositionClose{v} iNdEx = postIndex case 32: if wireType != 2 { @@ -12238,11 +7638,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.PositionWithdraw{} + v := &v1alpha15.PositionWithdraw{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_PositionWithdraw{v} + m.Action = &Action_PositionWithdraw{v} iNdEx = postIndex case 34: if wireType != 2 { @@ -12273,13 +7673,13 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.PositionRewardClaim{} + v := &v1alpha15.PositionRewardClaim{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_PositionRewardClaim{v} + m.Action = &Action_PositionRewardClaim{v} iNdEx = postIndex - case 41: + case 40: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Delegate", wireType) } @@ -12308,13 +7708,13 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha12.Delegate{} + v := &v1alpha16.Delegate{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_Delegate{v} + m.Action = &Action_Delegate{v} iNdEx = postIndex - case 42: + case 41: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Undelegate", wireType) } @@ -12343,13 +7743,13 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha12.Undelegate{} + v := &v1alpha16.Undelegate{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_Undelegate{v} + m.Action = &Action_Undelegate{v} iNdEx = postIndex - case 43: + case 42: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType) } @@ -12378,15 +7778,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha12.UndelegateClaim{} + v := &v1alpha16.UndelegateClaim{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_UndelegateClaim{v} + m.Action = &Action_UndelegateClaim{v} iNdEx = postIndex case 50: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoSpend", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolSpend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12413,15 +7813,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.DaoSpend{} + v := &v1alpha18.CommunityPoolSpend{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_DaoSpend{v} + m.Action = &Action_CommunityPoolSpend{v} iNdEx = postIndex case 51: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoOutput", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolOutput", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12448,15 +7848,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.DaoOutput{} + v := &v1alpha18.CommunityPoolOutput{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_DaoOutput{v} + m.Action = &Action_CommunityPoolOutput{v} iNdEx = postIndex case 52: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoDeposit", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolDeposit", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12483,11 +7883,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.DaoDeposit{} + v := &v1alpha18.CommunityPoolDeposit{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_DaoDeposit{v} + m.Action = &Action_CommunityPoolDeposit{v} iNdEx = postIndex case 200: if wireType != 2 { @@ -12518,11 +7918,11 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha13.Ics20Withdrawal{} + v := &v1alpha17.Ics20Withdrawal{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.ActionView = &ActionView_Ics20Withdrawal{v} + m.Action = &Action_Ics20Withdrawal{v} iNdEx = postIndex default: iNdEx = preIndex @@ -12545,7 +7945,7 @@ func (m *ActionView) Unmarshal(dAtA []byte) error { } return nil } -func (m *SpendView) Unmarshal(dAtA []byte) error { +func (m *TransactionPerspective) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12568,15 +7968,15 @@ func (m *SpendView) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SpendView: wiretype end group for non-group") + return fmt.Errorf("proto: TransactionPerspective: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SpendView: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TransactionPerspective: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PayloadKeys", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12603,15 +8003,14 @@ func (m *SpendView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &SpendView_Visible{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.PayloadKeys = append(m.PayloadKeys, &PayloadKeyWithCommitment{}) + if err := m.PayloadKeys[len(m.PayloadKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.SpendView = &SpendView_Visible_{v} iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SpendNullifiers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12638,65 +8037,82 @@ func (m *SpendView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &SpendView_Opaque{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.SpendNullifiers = append(m.SpendNullifiers, &NullifierWithNote{}) + if err := m.SpendNullifiers[len(m.SpendNullifiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.SpendView = &SpendView_Opaque_{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AdviceNotes", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTransaction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { return ErrInvalidLengthTransaction } - if (iNdEx + skippy) > l { + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTransaction + } + if postIndex > l { return io.ErrUnexpectedEOF } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SpendView_Visible) 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 ErrIntOverflowTransaction + m.AdviceNotes = append(m.AdviceNotes, &v1alpha14.Note{}) + if err := m.AdviceNotes[len(m.AdviceNotes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - if iNdEx >= l { + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AddressViews", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTransaction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTransaction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTransaction + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.AddressViews = append(m.AddressViews, &v1alpha19.AddressView{}) + if err := m.AddressViews[len(m.AddressViews)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Visible: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Denoms", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12723,16 +8139,14 @@ func (m *SpendView_Visible) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Spend == nil { - m.Spend = &Spend{} - } - if err := m.Spend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Denoms = append(m.Denoms, &v1alpha110.DenomMetadata{}) + if err := m.Denoms[len(m.Denoms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12759,10 +8173,10 @@ func (m *SpendView_Visible) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Note == nil { - m.Note = &v1alpha1.NoteView{} + if m.TransactionId == nil { + m.TransactionId = &v1alpha111.TransactionId{} } - if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.TransactionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -12787,7 +8201,7 @@ func (m *SpendView_Visible) Unmarshal(dAtA []byte) error { } return nil } -func (m *SpendView_Opaque) Unmarshal(dAtA []byte) error { +func (m *PayloadKeyWithCommitment) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12810,15 +8224,51 @@ func (m *SpendView_Opaque) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Opaque: wiretype end group for non-group") + return fmt.Errorf("proto: PayloadKeyWithCommitment: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PayloadKeyWithCommitment: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PayloadKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTransaction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTransaction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTransaction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PayloadKey == nil { + m.PayloadKey = &v1alpha19.PayloadKey{} + } + if err := m.PayloadKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commitment", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12845,10 +8295,10 @@ func (m *SpendView_Opaque) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Spend == nil { - m.Spend = &Spend{} + if m.Commitment == nil { + m.Commitment = &v1alpha11.StateCommitment{} } - if err := m.Spend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -12873,7 +8323,7 @@ func (m *SpendView_Opaque) Unmarshal(dAtA []byte) error { } return nil } -func (m *DelegatorVoteView) Unmarshal(dAtA []byte) error { +func (m *NullifierWithNote) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12896,15 +8346,15 @@ func (m *DelegatorVoteView) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DelegatorVoteView: wiretype end group for non-group") + return fmt.Errorf("proto: NullifierWithNote: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DelegatorVoteView: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: NullifierWithNote: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12931,15 +8381,16 @@ func (m *DelegatorVoteView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &DelegatorVoteView_Visible{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Nullifier == nil { + m.Nullifier = &v1alpha112.Nullifier{} + } + if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.DelegatorVote = &DelegatorVoteView_Visible_{v} iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12966,11 +8417,12 @@ func (m *DelegatorVoteView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &DelegatorVoteView_Opaque{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Note == nil { + m.Note = &v1alpha14.Note{} + } + if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.DelegatorVote = &DelegatorVoteView_Opaque_{v} iNdEx = postIndex default: iNdEx = preIndex @@ -12993,7 +8445,7 @@ func (m *DelegatorVoteView) Unmarshal(dAtA []byte) error { } return nil } -func (m *DelegatorVoteView_Visible) Unmarshal(dAtA []byte) error { +func (m *TransactionView) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13012,19 +8464,55 @@ func (m *DelegatorVoteView_Visible) Unmarshal(dAtA []byte) error { if b < 0x80 { break } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Visible: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TransactionView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TransactionView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BodyView", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTransaction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTransaction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTransaction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BodyView == nil { + m.BodyView = &TransactionBodyView{} + } + if err := m.BodyView.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BindingSig", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13051,16 +8539,16 @@ func (m *DelegatorVoteView_Visible) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DelegatorVote == nil { - m.DelegatorVote = &v1alpha14.DelegatorVote{} + if m.BindingSig == nil { + m.BindingSig = &v1alpha1.BindingSignature{} } - if err := m.DelegatorVote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.BindingSig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Anchor", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13087,10 +8575,10 @@ func (m *DelegatorVoteView_Visible) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Note == nil { - m.Note = &v1alpha1.NoteView{} + if m.Anchor == nil { + m.Anchor = &v1alpha11.MerkleRoot{} } - if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Anchor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -13115,7 +8603,7 @@ func (m *DelegatorVoteView_Visible) Unmarshal(dAtA []byte) error { } return nil } -func (m *DelegatorVoteView_Opaque) Unmarshal(dAtA []byte) error { +func (m *TransactionBodyView) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13138,15 +8626,15 @@ func (m *DelegatorVoteView_Opaque) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Opaque: wiretype end group for non-group") + return fmt.Errorf("proto: TransactionBodyView: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TransactionBodyView: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ActionViews", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13173,66 +8661,50 @@ func (m *DelegatorVoteView_Opaque) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DelegatorVote == nil { - m.DelegatorVote = &v1alpha14.DelegatorVote{} - } - if err := m.DelegatorVote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ActionViews = append(m.ActionViews, &ActionView{}) + if err := m.ActionViews[len(m.ActionViews)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionParameters", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTransaction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthTransaction } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *OutputView) 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 ErrIntOverflowTransaction + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTransaction } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.TransactionParameters == nil { + m.TransactionParameters = &TransactionParameters{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: OutputView: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: OutputView: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + if err := m.TransactionParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DetectionData", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13259,15 +8731,16 @@ func (m *OutputView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &OutputView_Visible{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.DetectionData == nil { + m.DetectionData = &DetectionData{} + } + if err := m.DetectionData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.OutputView = &OutputView_Visible_{v} iNdEx = postIndex - case 2: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MemoView", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13294,11 +8767,12 @@ func (m *OutputView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &OutputView_Opaque{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.MemoView == nil { + m.MemoView = &MemoView{} + } + if err := m.MemoView.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.OutputView = &OutputView_Opaque_{v} iNdEx = postIndex default: iNdEx = preIndex @@ -13321,7 +8795,7 @@ func (m *OutputView) Unmarshal(dAtA []byte) error { } return nil } -func (m *OutputView_Visible) Unmarshal(dAtA []byte) error { +func (m *ActionView) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13344,15 +8818,15 @@ func (m *OutputView_Visible) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Visible: wiretype end group for non-group") + return fmt.Errorf("proto: ActionView: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ActionView: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13379,16 +8853,15 @@ func (m *OutputView_Visible) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Output == nil { - m.Output = &Output{} - } - if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha14.SpendView{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_Spend{v} iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13415,16 +8888,15 @@ func (m *OutputView_Visible) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Note == nil { - m.Note = &v1alpha1.NoteView{} - } - if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha14.OutputView{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_Output{v} iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PayloadKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13451,66 +8923,15 @@ func (m *OutputView_Visible) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.PayloadKey == nil { - m.PayloadKey = &PayloadKey{} - } - if err := m.PayloadKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha15.SwapView{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_Swap{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *OutputView_Opaque) 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 ErrIntOverflowTransaction - } - 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: Opaque: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13537,66 +8958,50 @@ func (m *OutputView_Opaque) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Output == nil { - m.Output = &Output{} - } - if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha15.SwapClaimView{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_SwapClaim{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDefinition", wireType) } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTransaction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Spend) 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 ErrIntOverflowTransaction + if msglen < 0 { + return ErrInvalidLengthTransaction } - if iNdEx >= l { - return io.ErrUnexpectedEOF + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTransaction } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if postIndex > l { + return io.ErrUnexpectedEOF } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Spend: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Spend: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + v := &v1alpha16.ValidatorDefinition{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.ActionView = &ActionView_ValidatorDefinition{v} + iNdEx = postIndex + case 17: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IbcRelayAction", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13623,16 +9028,15 @@ func (m *Spend) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Body == nil { - m.Body = &SpendBody{} - } - if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha17.IbcRelay{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_IbcRelayAction{v} iNdEx = postIndex - case 2: + case 18: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ProposalSubmit", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13659,16 +9063,15 @@ func (m *Spend) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.AuthSig == nil { - m.AuthSig = &v1alpha1.SpendAuthSignature{} - } - if err := m.AuthSig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha18.ProposalSubmit{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_ProposalSubmit{v} iNdEx = postIndex - case 3: + case 19: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ProposalWithdraw", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13695,66 +9098,15 @@ func (m *Spend) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Proof == nil { - m.Proof = &v1alpha1.ZKSpendProof{} - } - if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha18.ProposalWithdraw{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_ProposalWithdraw{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SpendBody) 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 ErrIntOverflowTransaction - } - 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: SpendBody: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SpendBody: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 20: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorVote", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13781,18 +9133,17 @@ func (m *SpendBody) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.BalanceCommitment == nil { - m.BalanceCommitment = &v1alpha1.BalanceCommitment{} - } - if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha18.ValidatorVote{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_ValidatorVote{v} iNdEx = postIndex - case 3: + case 21: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -13802,31 +9153,32 @@ func (m *SpendBody) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.Nullifier = append(m.Nullifier[:0], dAtA[iNdEx:postIndex]...) - if m.Nullifier == nil { - m.Nullifier = []byte{} + v := &v1alpha18.DelegatorVoteView{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + m.ActionView = &ActionView_DelegatorVote{v} iNdEx = postIndex - case 4: + case 22: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Rk", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositClaim", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -13836,79 +9188,30 @@ func (m *SpendBody) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.Rk = append(m.Rk[:0], dAtA[iNdEx:postIndex]...) - if m.Rk == nil { - m.Rk = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { + v := &v1alpha18.ProposalDepositClaim{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Output) 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 ErrIntOverflowTransaction - } - 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: Output: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Output: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.ActionView = &ActionView_ProposalDepositClaim{v} + iNdEx = postIndex + case 30: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionOpen", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13935,16 +9238,15 @@ func (m *Output) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Body == nil { - m.Body = &OutputBody{} - } - if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha15.PositionOpen{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_PositionOpen{v} iNdEx = postIndex - case 2: + case 31: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionClose", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13971,66 +9273,15 @@ func (m *Output) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Proof == nil { - m.Proof = &v1alpha1.ZKOutputProof{} - } - if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha15.PositionClose{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_PositionClose{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *OutputBody) 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 ErrIntOverflowTransaction - } - 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: OutputBody: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: OutputBody: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 32: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NotePayload", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionWithdraw", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14057,16 +9308,15 @@ func (m *OutputBody) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.NotePayload == nil { - m.NotePayload = &v1alpha1.NotePayload{} - } - if err := m.NotePayload.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha15.PositionWithdraw{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_PositionWithdraw{v} iNdEx = postIndex - case 2: + case 34: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionRewardClaim", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14093,18 +9343,17 @@ func (m *OutputBody) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.BalanceCommitment == nil { - m.BalanceCommitment = &v1alpha1.BalanceCommitment{} - } - if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha15.PositionRewardClaim{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_PositionRewardClaim{v} iNdEx = postIndex - case 3: + case 41: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field WrappedMemoKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Delegate", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -14114,31 +9363,32 @@ func (m *OutputBody) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.WrappedMemoKey = append(m.WrappedMemoKey[:0], dAtA[iNdEx:postIndex]...) - if m.WrappedMemoKey == nil { - m.WrappedMemoKey = []byte{} + v := &v1alpha16.Delegate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + m.ActionView = &ActionView_Delegate{v} iNdEx = postIndex - case 4: + case 42: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field OvkWrappedKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Undelegate", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -14148,79 +9398,30 @@ func (m *OutputBody) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.OvkWrappedKey = append(m.OvkWrappedKey[:0], dAtA[iNdEx:postIndex]...) - if m.OvkWrappedKey == nil { - m.OvkWrappedKey = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { + v := &v1alpha16.Undelegate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AuthorizationData) 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 ErrIntOverflowTransaction - } - 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: AuthorizationData: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AuthorizationData: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.ActionView = &ActionView_Undelegate{v} + iNdEx = postIndex + case 43: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EffectHash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14247,16 +9448,15 @@ func (m *AuthorizationData) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.EffectHash == nil { - m.EffectHash = &v1alpha1.EffectHash{} - } - if err := m.EffectHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha16.UndelegateClaim{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_UndelegateClaim{v} iNdEx = postIndex - case 2: + case 50: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SpendAuths", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolSpend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14283,14 +9483,15 @@ func (m *AuthorizationData) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SpendAuths = append(m.SpendAuths, &v1alpha1.SpendAuthSignature{}) - if err := m.SpendAuths[len(m.SpendAuths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha18.CommunityPoolSpend{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_CommunityPoolSpend{v} iNdEx = postIndex - case 3: + case 51: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVoteAuths", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolOutput", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14317,64 +9518,15 @@ func (m *AuthorizationData) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.DelegatorVoteAuths = append(m.DelegatorVoteAuths, &v1alpha1.SpendAuthSignature{}) - if err := m.DelegatorVoteAuths[len(m.DelegatorVoteAuths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha18.CommunityPoolOutput{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_CommunityPoolOutput{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *WitnessData) 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 ErrIntOverflowTransaction - } - 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: WitnessData: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: WitnessData: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 52: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Anchor", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolDeposit", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14401,16 +9553,15 @@ func (m *WitnessData) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Anchor == nil { - m.Anchor = &v1alpha1.MerkleRoot{} - } - if err := m.Anchor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha18.CommunityPoolDeposit{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_CommunityPoolDeposit{v} iNdEx = postIndex - case 2: + case 200: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StateCommitmentProofs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ics20Withdrawal", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14437,10 +9588,11 @@ func (m *WitnessData) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.StateCommitmentProofs = append(m.StateCommitmentProofs, &v1alpha1.StateCommitmentProof{}) - if err := m.StateCommitmentProofs[len(m.StateCommitmentProofs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha17.Ics20Withdrawal{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.ActionView = &ActionView_Ics20Withdrawal{v} iNdEx = postIndex default: iNdEx = preIndex @@ -14463,7 +9615,7 @@ func (m *WitnessData) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransactionPlan) Unmarshal(dAtA []byte) error { +func (m *AuthorizationData) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14486,15 +9638,15 @@ func (m *TransactionPlan) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TransactionPlan: wiretype end group for non-group") + return fmt.Errorf("proto: AuthorizationData: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TransactionPlan: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AuthorizationData: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EffectHash", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14521,35 +9673,18 @@ func (m *TransactionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Actions = append(m.Actions, &ActionPlan{}) - if err := m.Actions[len(m.Actions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.EffectHash == nil { + m.EffectHash = &v1alpha111.EffectHash{} + } + if err := m.EffectHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ExpiryHeight", wireType) - } - m.ExpiryHeight = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ExpiryHeight |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SpendAuths", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -14559,27 +9694,29 @@ func (m *TransactionPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.ChainId = string(dAtA[iNdEx:postIndex]) + m.SpendAuths = append(m.SpendAuths, &v1alpha1.SpendAuthSignature{}) + if err := m.SpendAuths[len(m.SpendAuths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 4: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVoteAuths", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14606,16 +9743,64 @@ func (m *TransactionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Fee == nil { - m.Fee = &v1alpha1.Fee{} - } - if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.DelegatorVoteAuths = append(m.DelegatorVoteAuths, &v1alpha1.SpendAuthSignature{}) + if err := m.DelegatorVoteAuths[len(m.DelegatorVoteAuths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: + default: + iNdEx = preIndex + skippy, err := skipTransaction(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTransaction + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WitnessData) 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 ErrIntOverflowTransaction + } + 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: WitnessData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WitnessData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CluePlans", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Anchor", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14642,14 +9827,16 @@ func (m *TransactionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.CluePlans = append(m.CluePlans, &CluePlan{}) - if err := m.CluePlans[len(m.CluePlans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Anchor == nil { + m.Anchor = &v1alpha11.MerkleRoot{} + } + if err := m.Anchor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 6: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MemoPlan", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StateCommitmentProofs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14676,10 +9863,8 @@ func (m *TransactionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.MemoPlan == nil { - m.MemoPlan = &MemoPlan{} - } - if err := m.MemoPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.StateCommitmentProofs = append(m.StateCommitmentProofs, &v1alpha11.StateCommitmentProof{}) + if err := m.StateCommitmentProofs[len(m.StateCommitmentProofs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -14704,7 +9889,7 @@ func (m *TransactionPlan) Unmarshal(dAtA []byte) error { } return nil } -func (m *ActionPlan) Unmarshal(dAtA []byte) error { +func (m *TransactionPlan) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14727,15 +9912,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ActionPlan: wiretype end group for non-group") + return fmt.Errorf("proto: TransactionPlan: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ActionPlan: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TransactionPlan: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14762,15 +9947,14 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &SpendPlan{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Actions = append(m.Actions, &ActionPlan{}) + if err := m.Actions[len(m.Actions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_Spend{v} iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TransactionParameters", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14797,50 +9981,16 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &OutputPlan{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Action = &ActionPlan_Output{v} - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF + if m.TransactionParameters == nil { + m.TransactionParameters = &TransactionParameters{} } - v := &v1alpha11.SwapPlan{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.TransactionParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_Swap{v} iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DetectionData", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14867,15 +10017,16 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.SwapClaimPlan{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.DetectionData == nil { + m.DetectionData = &DetectionDataPlan{} + } + if err := m.DetectionData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_SwapClaim{v} iNdEx = postIndex - case 16: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDefinition", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Memo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14902,50 +10053,66 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha12.ValidatorDefinition{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Memo == nil { + m.Memo = &MemoPlan{} + } + if err := m.Memo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_ValidatorDefinition{v} iNdEx = postIndex - case 17: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IbcAction", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } + default: + iNdEx = preIndex + skippy, err := skipTransaction(dAtA[iNdEx:]) + if err != nil { + return err } - if msglen < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - if postIndex > l { + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DetectionDataPlan) 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 ErrIntOverflowTransaction + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - v := &v1alpha13.IbcAction{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - m.Action = &ActionPlan_IbcAction{v} - iNdEx = postIndex - case 18: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DetectionDataPlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DetectionDataPlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalSubmit", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CluePlans", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14972,50 +10139,64 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.ProposalSubmit{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.CluePlans = append(m.CluePlans, &CluePlan{}) + if err := m.CluePlans[len(m.CluePlans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_ProposalSubmit{v} iNdEx = postIndex - case 19: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalWithdraw", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } + default: + iNdEx = preIndex + skippy, err := skipTransaction(dAtA[iNdEx:]) + if err != nil { + return err } - if msglen < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransaction + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - if postIndex > l { + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ActionPlan) 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 ErrIntOverflowTransaction + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - v := &v1alpha14.ProposalWithdraw{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - m.Action = &ActionPlan_ProposalWithdraw{v} - iNdEx = postIndex - case 20: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ActionPlan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ActionPlan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorVote", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15042,15 +10223,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.ValidatorVote{} + v := &v1alpha14.SpendPlan{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_ValidatorVote{v} + m.Action = &ActionPlan_Spend{v} iNdEx = postIndex - case 21: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15077,15 +10258,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.DelegatorVotePlan{} + v := &v1alpha14.OutputPlan{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_DelegatorVote{v} + m.Action = &ActionPlan_Output{v} iNdEx = postIndex - case 22: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositClaim", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15112,15 +10293,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.ProposalDepositClaim{} + v := &v1alpha15.SwapPlan{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_ProposalDepositClaim{v} + m.Action = &ActionPlan_Swap{v} iNdEx = postIndex - case 23: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Withdrawal", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15147,15 +10328,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha13.Ics20Withdrawal{} + v := &v1alpha15.SwapClaimPlan{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_Withdrawal{v} + m.Action = &ActionPlan_SwapClaim{v} iNdEx = postIndex - case 30: + case 16: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionOpen", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDefinition", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15182,15 +10363,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.PositionOpen{} + v := &v1alpha16.ValidatorDefinition{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_PositionOpen{v} + m.Action = &ActionPlan_ValidatorDefinition{v} iNdEx = postIndex - case 31: + case 17: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionClose", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IbcRelayAction", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15217,15 +10398,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.PositionClose{} + v := &v1alpha17.IbcRelay{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_PositionClose{v} + m.Action = &ActionPlan_IbcRelayAction{v} iNdEx = postIndex - case 32: + case 18: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionWithdraw", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ProposalSubmit", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15252,15 +10433,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.PositionWithdrawPlan{} + v := &v1alpha18.ProposalSubmit{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_PositionWithdraw{v} + m.Action = &ActionPlan_ProposalSubmit{v} iNdEx = postIndex - case 34: + case 19: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PositionRewardClaim", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ProposalWithdraw", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15287,15 +10468,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.PositionRewardClaimPlan{} + v := &v1alpha18.ProposalWithdraw{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_PositionRewardClaim{v} + m.Action = &ActionPlan_ProposalWithdraw{v} iNdEx = postIndex - case 40: + case 20: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Delegate", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorVote", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15322,15 +10503,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha12.Delegate{} + v := &v1alpha18.ValidatorVote{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_Delegate{v} + m.Action = &ActionPlan_ValidatorVote{v} iNdEx = postIndex - case 41: + case 21: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Undelegate", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15357,15 +10538,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha12.Undelegate{} + v := &v1alpha18.DelegatorVotePlan{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_Undelegate{v} + m.Action = &ActionPlan_DelegatorVote{v} iNdEx = postIndex - case 42: + case 22: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositClaim", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15392,15 +10573,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha12.UndelegateClaimPlan{} + v := &v1alpha18.ProposalDepositClaim{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_UndelegateClaim{v} + m.Action = &ActionPlan_ProposalDepositClaim{v} iNdEx = postIndex - case 50: + case 23: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoSpend", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawal", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15427,15 +10608,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.DaoSpend{} + v := &v1alpha17.Ics20Withdrawal{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_DaoSpend{v} + m.Action = &ActionPlan_Withdrawal{v} iNdEx = postIndex - case 51: + case 30: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoOutput", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionOpen", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15462,15 +10643,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.DaoOutput{} + v := &v1alpha15.PositionOpen{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_DaoOutput{v} + m.Action = &ActionPlan_PositionOpen{v} iNdEx = postIndex - case 52: + case 31: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaoDeposit", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionClose", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15497,65 +10678,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha14.DaoDeposit{} + v := &v1alpha15.PositionClose{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Action = &ActionPlan_DaoDeposit{v} + m.Action = &ActionPlan_PositionClose{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *CluePlan) 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 ErrIntOverflowTransaction - } - 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: CluePlan: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: CluePlan: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 32: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionWithdraw", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15582,18 +10713,17 @@ func (m *CluePlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Address == nil { - m.Address = &v1alpha1.Address{} - } - if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha15.PositionWithdrawPlan{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.Action = &ActionPlan_PositionWithdraw{v} iNdEx = postIndex - case 2: + case 34: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionRewardClaim", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -15603,31 +10733,32 @@ func (m *CluePlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) - if m.Rseed == nil { - m.Rseed = []byte{} + v := &v1alpha15.PositionRewardClaimPlan{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + m.Action = &ActionPlan_PositionRewardClaim{v} iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PrecisionBits", wireType) + case 40: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delegate", wireType) } - m.PrecisionBits = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -15637,64 +10768,30 @@ func (m *CluePlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PrecisionBits |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MemoPlan) 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 ErrIntOverflowTransaction + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTransaction } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + v := &v1alpha16.Delegate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MemoPlan: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MemoPlan: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.Action = &ActionPlan_Delegate{v} + iNdEx = postIndex + case 41: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plaintext", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Undelegate", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15721,18 +10818,17 @@ func (m *MemoPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Plaintext == nil { - m.Plaintext = &MemoPlaintext{} - } - if err := m.Plaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha16.Undelegate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.Action = &ActionPlan_Undelegate{v} iNdEx = postIndex - case 2: + case 42: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -15742,81 +10838,32 @@ func (m *MemoPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) - if m.Key == nil { - m.Key = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MemoCiphertext) 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 ErrIntOverflowTransaction - } - 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: MemoCiphertext: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MemoCiphertext: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + v := &v1alpha16.UndelegateClaimPlan{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Action = &ActionPlan_UndelegateClaim{v} + iNdEx = postIndex + case 50: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolSpend", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -15826,79 +10873,30 @@ func (m *MemoCiphertext) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransaction(dAtA[iNdEx:]) - if err != nil { + v := &v1alpha18.CommunityPoolSpend{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransaction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MemoPlaintext) 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 ErrIntOverflowTransaction - } - 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: MemoPlaintext: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MemoPlaintext: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.Action = &ActionPlan_CommunityPoolSpend{v} + iNdEx = postIndex + case 51: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolOutput", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15925,18 +10923,17 @@ func (m *MemoPlaintext) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Sender == nil { - m.Sender = &v1alpha1.Address{} - } - if err := m.Sender.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &v1alpha18.CommunityPoolOutput{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.Action = &ActionPlan_CommunityPoolOutput{v} iNdEx = postIndex - case 2: + case 52: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolDeposit", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -15946,23 +10943,26 @@ func (m *MemoPlaintext) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.Text = string(dAtA[iNdEx:postIndex]) + v := &v1alpha18.CommunityPoolDeposit{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Action = &ActionPlan_CommunityPoolDeposit{v} iNdEx = postIndex default: iNdEx = preIndex @@ -15985,7 +10985,7 @@ func (m *MemoPlaintext) Unmarshal(dAtA []byte) error { } return nil } -func (m *MemoView) Unmarshal(dAtA []byte) error { +func (m *CluePlan) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16008,15 +11008,15 @@ func (m *MemoView) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MemoView: wiretype end group for non-group") + return fmt.Errorf("proto: CluePlan: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MemoView: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CluePlan: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16043,17 +11043,18 @@ func (m *MemoView) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &MemoView_Visible{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Address == nil { + m.Address = &v1alpha19.Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.MemoView = &MemoView_Visible_{v} iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -16063,27 +11064,45 @@ func (m *MemoView) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - v := &MemoView_Opaque{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) + if m.Rseed == nil { + m.Rseed = []byte{} } - m.MemoView = &MemoView_Opaque_{v} iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrecisionBits", wireType) + } + m.PrecisionBits = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTransaction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PrecisionBits |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTransaction(dAtA[iNdEx:]) @@ -16105,7 +11124,7 @@ func (m *MemoView) Unmarshal(dAtA []byte) error { } return nil } -func (m *MemoView_Visible) Unmarshal(dAtA []byte) error { +func (m *MemoPlan) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16128,15 +11147,15 @@ func (m *MemoView_Visible) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Visible: wiretype end group for non-group") + return fmt.Errorf("proto: MemoPlan: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MemoPlan: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ciphertext", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Plaintext", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16163,18 +11182,18 @@ func (m *MemoView_Visible) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Ciphertext == nil { - m.Ciphertext = &MemoCiphertext{} + if m.Plaintext == nil { + m.Plaintext = &MemoPlaintext{} } - if err := m.Ciphertext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Plaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plaintext", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -16184,26 +11203,24 @@ func (m *MemoView_Visible) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Plaintext == nil { - m.Plaintext = &MemoPlaintext{} - } - if err := m.Plaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} } iNdEx = postIndex default: @@ -16227,7 +11244,7 @@ func (m *MemoView_Visible) Unmarshal(dAtA []byte) error { } return nil } -func (m *MemoView_Opaque) Unmarshal(dAtA []byte) error { +func (m *MemoCiphertext) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16250,17 +11267,17 @@ func (m *MemoView_Opaque) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Opaque: wiretype end group for non-group") + return fmt.Errorf("proto: MemoCiphertext: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MemoCiphertext: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ciphertext", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -16270,26 +11287,24 @@ func (m *MemoView_Opaque) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Ciphertext == nil { - m.Ciphertext = &MemoCiphertext{} - } - if err := m.Ciphertext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} } iNdEx = postIndex default: @@ -16313,7 +11328,7 @@ func (m *MemoView_Opaque) Unmarshal(dAtA []byte) error { } return nil } -func (m *SpendPlan) Unmarshal(dAtA []byte) error { +func (m *MemoPlaintext) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16336,15 +11351,15 @@ func (m *SpendPlan) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SpendPlan: wiretype end group for non-group") + return fmt.Errorf("proto: MemoPlaintext: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SpendPlan: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MemoPlaintext: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReturnAddress", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16371,71 +11386,18 @@ func (m *SpendPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Note == nil { - m.Note = &v1alpha1.Note{} + if m.ReturnAddress == nil { + m.ReturnAddress = &v1alpha19.Address{} } - if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ReturnAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) - } - m.Position = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Position |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Randomizer", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTransaction - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTransaction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Randomizer = append(m.Randomizer[:0], dAtA[iNdEx:postIndex]...) - if m.Randomizer == nil { - m.Randomizer = []byte{} - } - iNdEx = postIndex - case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValueBlinding", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -16445,31 +11407,79 @@ func (m *SpendPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.ValueBlinding = append(m.ValueBlinding[:0], dAtA[iNdEx:postIndex]...) - if m.ValueBlinding == nil { - m.ValueBlinding = []byte{} - } + m.Text = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + default: + iNdEx = preIndex + skippy, err := skipTransaction(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTransaction + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemoPlaintextView) 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 ErrIntOverflowTransaction + } + 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: MemoPlaintextView: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MemoPlaintextView: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReturnAddress", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -16479,31 +11489,33 @@ func (m *SpendPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingR == nil { - m.ProofBlindingR = []byte{} + if m.ReturnAddress == nil { + m.ReturnAddress = &v1alpha19.AddressView{} + } + if err := m.ReturnAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex - case 6: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -16513,25 +11525,23 @@ func (m *SpendPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingS == nil { - m.ProofBlindingS = []byte{} - } + m.Text = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -16554,7 +11564,7 @@ func (m *SpendPlan) Unmarshal(dAtA []byte) error { } return nil } -func (m *OutputPlan) Unmarshal(dAtA []byte) error { +func (m *MemoView) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16577,15 +11587,15 @@ func (m *OutputPlan) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: OutputPlan: wiretype end group for non-group") + return fmt.Errorf("proto: MemoView: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: OutputPlan: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MemoView: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16612,16 +11622,15 @@ func (m *OutputPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Value == nil { - m.Value = &v1alpha1.Value{} - } - if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &MemoView_Visible{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.MemoView = &MemoView_Visible_{v} iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DestAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Opaque", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16648,52 +11657,67 @@ func (m *OutputPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DestAddress == nil { - m.DestAddress = &v1alpha1.Address{} - } - if err := m.DestAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &MemoView_Opaque{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.MemoView = &MemoView_Opaque_{v} iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Rseed", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransaction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } + default: + iNdEx = preIndex + skippy, err := skipTransaction(dAtA[iNdEx:]) + if err != nil { + return err } - if byteLen < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTransaction + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - if postIndex > l { + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemoView_Visible) 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 ErrIntOverflowTransaction + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.Rseed = append(m.Rseed[:0], dAtA[iNdEx:postIndex]...) - if m.Rseed == nil { - m.Rseed = []byte{} + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 4: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Visible: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Visible: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValueBlinding", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ciphertext", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -16703,31 +11727,33 @@ func (m *OutputPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.ValueBlinding = append(m.ValueBlinding[:0], dAtA[iNdEx:postIndex]...) - if m.ValueBlinding == nil { - m.ValueBlinding = []byte{} + if m.Ciphertext == nil { + m.Ciphertext = &MemoCiphertext{} + } + if err := m.Ciphertext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex - case 5: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Plaintext", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -16737,31 +11763,83 @@ func (m *OutputPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingR == nil { - m.ProofBlindingR = []byte{} + if m.Plaintext == nil { + m.Plaintext = &MemoPlaintextView{} + } + if err := m.Plaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex - case 6: + default: + iNdEx = preIndex + skippy, err := skipTransaction(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTransaction + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MemoView_Opaque) 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 ErrIntOverflowTransaction + } + 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: Opaque: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Opaque: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ciphertext", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTransaction @@ -16771,24 +11849,26 @@ func (m *OutputPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTransaction } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTransaction } if postIndex > l { return io.ErrUnexpectedEOF } - m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...) - if m.ProofBlindingS == nil { - m.ProofBlindingS = []byte{} + if m.Ciphertext == nil { + m.Ciphertext = &MemoCiphertext{} + } + if err := m.Ciphertext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: diff --git a/relayer/chains/penumbra/core/transparent_proofs/v1alpha1/transparent_proofs.pb.go b/relayer/chains/penumbra/core/transparent_proofs/v1alpha1/transparent_proofs.pb.go deleted file mode 100644 index 61dc0d957..000000000 --- a/relayer/chains/penumbra/core/transparent_proofs/v1alpha1/transparent_proofs.pb.go +++ /dev/null @@ -1,589 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: penumbra/core/transparent_proofs/v1alpha1/transparent_proofs.proto - -package transparent_proofsv1alpha1 - -import ( - fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" - v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" - v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/dex/v1alpha1" - 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 - -// A Penumbra transparent SwapClaimProof. -type SwapClaimProof struct { - // The swap being claimed - SwapPlaintext *v1alpha1.SwapPlaintext `protobuf:"bytes,1,opt,name=swap_plaintext,json=swapPlaintext,proto3" json:"swap_plaintext,omitempty"` - // Inclusion proof for the swap commitment - SwapCommitmentProof *v1alpha11.StateCommitmentProof `protobuf:"bytes,4,opt,name=swap_commitment_proof,json=swapCommitmentProof,proto3" json:"swap_commitment_proof,omitempty"` - // The nullifier key used to derive the swap nullifier - Nk []byte `protobuf:"bytes,6,opt,name=nk,proto3" json:"nk,omitempty"` - // - // @exclude - // Describes output amounts - Lambda_1I *v1alpha11.Amount `protobuf:"bytes,20,opt,name=lambda_1_i,json=lambda1I,proto3" json:"lambda_1_i,omitempty"` - Lambda_2I *v1alpha11.Amount `protobuf:"bytes,21,opt,name=lambda_2_i,json=lambda2I,proto3" json:"lambda_2_i,omitempty"` -} - -func (m *SwapClaimProof) Reset() { *m = SwapClaimProof{} } -func (m *SwapClaimProof) String() string { return proto.CompactTextString(m) } -func (*SwapClaimProof) ProtoMessage() {} -func (*SwapClaimProof) Descriptor() ([]byte, []int) { - return fileDescriptor_1536b20e10cd99e5, []int{0} -} -func (m *SwapClaimProof) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapClaimProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapClaimProof.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 *SwapClaimProof) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapClaimProof.Merge(m, src) -} -func (m *SwapClaimProof) XXX_Size() int { - return m.Size() -} -func (m *SwapClaimProof) XXX_DiscardUnknown() { - xxx_messageInfo_SwapClaimProof.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapClaimProof proto.InternalMessageInfo - -func (m *SwapClaimProof) GetSwapPlaintext() *v1alpha1.SwapPlaintext { - if m != nil { - return m.SwapPlaintext - } - return nil -} - -func (m *SwapClaimProof) GetSwapCommitmentProof() *v1alpha11.StateCommitmentProof { - if m != nil { - return m.SwapCommitmentProof - } - return nil -} - -func (m *SwapClaimProof) GetNk() []byte { - if m != nil { - return m.Nk - } - return nil -} - -func (m *SwapClaimProof) GetLambda_1I() *v1alpha11.Amount { - if m != nil { - return m.Lambda_1I - } - return nil -} - -func (m *SwapClaimProof) GetLambda_2I() *v1alpha11.Amount { - if m != nil { - return m.Lambda_2I - } - return nil -} - -func init() { - proto.RegisterType((*SwapClaimProof)(nil), "penumbra.core.transparent_proofs.v1alpha1.SwapClaimProof") -} - -func init() { - proto.RegisterFile("penumbra/core/transparent_proofs/v1alpha1/transparent_proofs.proto", fileDescriptor_1536b20e10cd99e5) -} - -var fileDescriptor_1536b20e10cd99e5 = []byte{ - // 448 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0x3f, 0x6f, 0xd3, 0x40, - 0x18, 0xc6, 0x63, 0x17, 0x55, 0xe8, 0x80, 0x0c, 0x86, 0x22, 0xab, 0x83, 0x55, 0x21, 0x90, 0x52, - 0x10, 0x67, 0x25, 0x65, 0x32, 0x13, 0xf1, 0x80, 0x3a, 0x20, 0x9d, 0x42, 0xc5, 0x80, 0x22, 0x59, - 0x6f, 0x9c, 0xa3, 0xb1, 0xea, 0xfb, 0xa3, 0xbb, 0x4b, 0x9b, 0x7e, 0x0b, 0x06, 0x3e, 0x01, 0x23, - 0x9f, 0x04, 0x31, 0x75, 0x64, 0x44, 0x89, 0x58, 0xf8, 0x14, 0xe8, 0x9c, 0x5e, 0xdc, 0xd4, 0x91, - 0x88, 0xd8, 0x7c, 0x7e, 0x9f, 0xe7, 0xf7, 0x3c, 0xaf, 0x7c, 0x46, 0x7d, 0x49, 0xf9, 0x94, 0x8d, - 0x14, 0xc4, 0xb9, 0x50, 0x34, 0x36, 0x0a, 0xb8, 0x96, 0xa0, 0x28, 0x37, 0x99, 0x54, 0x42, 0x7c, - 0xd2, 0xf1, 0x79, 0x17, 0x4a, 0x39, 0x81, 0xee, 0x86, 0x19, 0x96, 0x4a, 0x18, 0x11, 0x1c, 0x3a, - 0x06, 0xb6, 0x0c, 0xbc, 0x41, 0xe7, 0x18, 0xfb, 0xcf, 0xd7, 0xe3, 0x72, 0x75, 0x29, 0x8d, 0xa8, - 0x23, 0x96, 0xe7, 0x25, 0x76, 0xff, 0xe9, 0xba, 0x76, 0x4c, 0x67, 0xb5, 0x70, 0x4c, 0x67, 0x4b, - 0xd5, 0x93, 0xdf, 0x3e, 0x6a, 0xbf, 0xbf, 0x00, 0x99, 0x96, 0x50, 0x30, 0x62, 0xe3, 0x02, 0x82, - 0xda, 0xfa, 0x02, 0x64, 0x26, 0x4b, 0x28, 0xb8, 0xa1, 0x33, 0x13, 0x7a, 0x07, 0x5e, 0xe7, 0x5e, - 0xef, 0x10, 0xaf, 0x17, 0xb5, 0x10, 0x47, 0xc4, 0x96, 0x41, 0x9c, 0x61, 0xf0, 0x40, 0xdf, 0x3c, - 0x06, 0xa7, 0x68, 0xaf, 0x22, 0xe6, 0x82, 0xb1, 0xc2, 0xb0, 0xd5, 0x66, 0xe1, 0x9d, 0x0a, 0x7c, - 0x74, 0x0b, 0x7c, 0xbd, 0x46, 0xcd, 0x36, 0x60, 0x68, 0xba, 0xf2, 0x56, 0x2d, 0x07, 0x0f, 0x2d, - 0xf1, 0xd6, 0xcb, 0xa0, 0x8d, 0x7c, 0x7e, 0x16, 0xee, 0x1e, 0x78, 0x9d, 0xfb, 0x03, 0x9f, 0x9f, - 0x05, 0x29, 0x42, 0x25, 0xb0, 0xd1, 0x18, 0xb2, 0x6e, 0x56, 0x84, 0x8f, 0xaa, 0xb4, 0x67, 0xff, - 0x48, 0x7b, 0xc3, 0xc4, 0x94, 0x9b, 0xc1, 0xdd, 0xa5, 0xb1, 0x7b, 0x7c, 0x03, 0xd2, 0xcb, 0x8a, - 0x70, 0xef, 0x3f, 0x20, 0xbd, 0xe3, 0xfe, 0x97, 0x9d, 0xef, 0xf3, 0xc8, 0xbb, 0x9a, 0x47, 0xde, - 0xaf, 0x79, 0xe4, 0x7d, 0x5e, 0x44, 0xad, 0xab, 0x45, 0xd4, 0xfa, 0xb9, 0x88, 0x5a, 0xe8, 0x65, - 0x2e, 0x18, 0xde, 0xfa, 0x0e, 0xf4, 0x1f, 0x9f, 0xd4, 0xc3, 0x6a, 0x6b, 0x4d, 0xec, 0x97, 0x24, - 0xde, 0x47, 0x79, 0x5a, 0x98, 0xc9, 0x74, 0x84, 0x73, 0xc1, 0xe2, 0x5c, 0x68, 0x26, 0x74, 0xac, - 0x68, 0x09, 0x97, 0x54, 0xc5, 0xe7, 0xbd, 0xd5, 0x63, 0x3e, 0x81, 0x82, 0xeb, 0x78, 0xeb, 0x8b, - 0xfb, 0xba, 0x39, 0x73, 0xa3, 0xaf, 0xfe, 0x0e, 0x49, 0x4f, 0xbe, 0xf9, 0x1d, 0xe2, 0xda, 0xa7, - 0xb6, 0x7d, 0xa3, 0x20, 0xfe, 0x70, 0x6d, 0xf8, 0x51, 0x4b, 0x87, 0x56, 0x3a, 0x6c, 0x48, 0x87, - 0x4e, 0x3a, 0xf7, 0x5f, 0x6d, 0x2b, 0x1d, 0xbe, 0x25, 0xfd, 0x77, 0xd4, 0xc0, 0x18, 0x0c, 0xfc, - 0xf1, 0x5f, 0x38, 0x5b, 0x92, 0x58, 0x5f, 0x92, 0x34, 0x8c, 0x49, 0xe2, 0x9c, 0xa3, 0xdd, 0xea, - 0x2f, 0x38, 0xfa, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x7e, 0xa6, 0x57, 0xdf, 0xc8, 0x03, 0x00, 0x00, -} - -func (m *SwapClaimProof) 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 *SwapClaimProof) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapClaimProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Lambda_2I != nil { - { - size, err := m.Lambda_2I.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransparentProofs(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xaa - } - if m.Lambda_1I != nil { - { - size, err := m.Lambda_1I.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransparentProofs(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa2 - } - if len(m.Nk) > 0 { - i -= len(m.Nk) - copy(dAtA[i:], m.Nk) - i = encodeVarintTransparentProofs(dAtA, i, uint64(len(m.Nk))) - i-- - dAtA[i] = 0x32 - } - if m.SwapCommitmentProof != nil { - { - size, err := m.SwapCommitmentProof.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransparentProofs(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.SwapPlaintext != nil { - { - size, err := m.SwapPlaintext.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTransparentProofs(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func encodeVarintTransparentProofs(dAtA []byte, offset int, v uint64) int { - offset -= sovTransparentProofs(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *SwapClaimProof) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SwapPlaintext != nil { - l = m.SwapPlaintext.Size() - n += 1 + l + sovTransparentProofs(uint64(l)) - } - if m.SwapCommitmentProof != nil { - l = m.SwapCommitmentProof.Size() - n += 1 + l + sovTransparentProofs(uint64(l)) - } - l = len(m.Nk) - if l > 0 { - n += 1 + l + sovTransparentProofs(uint64(l)) - } - if m.Lambda_1I != nil { - l = m.Lambda_1I.Size() - n += 2 + l + sovTransparentProofs(uint64(l)) - } - if m.Lambda_2I != nil { - l = m.Lambda_2I.Size() - n += 2 + l + sovTransparentProofs(uint64(l)) - } - return n -} - -func sovTransparentProofs(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozTransparentProofs(x uint64) (n int) { - return sovTransparentProofs(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *SwapClaimProof) 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 ErrIntOverflowTransparentProofs - } - 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: SwapClaimProof: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapClaimProof: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapPlaintext", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransparentProofs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransparentProofs - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransparentProofs - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.SwapPlaintext == nil { - m.SwapPlaintext = &v1alpha1.SwapPlaintext{} - } - if err := m.SwapPlaintext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapCommitmentProof", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransparentProofs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransparentProofs - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransparentProofs - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.SwapCommitmentProof == nil { - m.SwapCommitmentProof = &v1alpha11.StateCommitmentProof{} - } - if err := m.SwapCommitmentProof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Nk", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransparentProofs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTransparentProofs - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTransparentProofs - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Nk = append(m.Nk[:0], dAtA[iNdEx:postIndex]...) - if m.Nk == nil { - m.Nk = []byte{} - } - iNdEx = postIndex - case 20: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Lambda_1I", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransparentProofs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransparentProofs - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransparentProofs - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Lambda_1I == nil { - m.Lambda_1I = &v1alpha11.Amount{} - } - if err := m.Lambda_1I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 21: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Lambda_2I", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTransparentProofs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTransparentProofs - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTransparentProofs - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Lambda_2I == nil { - m.Lambda_2I = &v1alpha11.Amount{} - } - if err := m.Lambda_2I.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTransparentProofs(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTransparentProofs - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipTransparentProofs(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, ErrIntOverflowTransparentProofs - } - 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, ErrIntOverflowTransparentProofs - } - 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, ErrIntOverflowTransparentProofs - } - 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, ErrInvalidLengthTransparentProofs - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupTransparentProofs - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthTransparentProofs - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthTransparentProofs = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowTransparentProofs = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupTransparentProofs = fmt.Errorf("proto: unexpected end of group") -) diff --git a/relayer/chains/penumbra/core/txhash/v1alpha1/txhash.pb.go b/relayer/chains/penumbra/core/txhash/v1alpha1/txhash.pb.go new file mode 100644 index 000000000..5e1a33653 --- /dev/null +++ b/relayer/chains/penumbra/core/txhash/v1alpha1/txhash.pb.go @@ -0,0 +1,504 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/core/txhash/v1alpha1/txhash.proto + +package txhashv1alpha1 + +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 + +// The hash of a Penumbra transaction's _effecting data_, describing the effects +// of the transaction on the chain state. +type EffectHash struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *EffectHash) Reset() { *m = EffectHash{} } +func (m *EffectHash) String() string { return proto.CompactTextString(m) } +func (*EffectHash) ProtoMessage() {} +func (*EffectHash) Descriptor() ([]byte, []int) { + return fileDescriptor_be98fc5f1d1ce16e, []int{0} +} +func (m *EffectHash) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EffectHash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EffectHash.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 *EffectHash) XXX_Merge(src proto.Message) { + xxx_messageInfo_EffectHash.Merge(m, src) +} +func (m *EffectHash) XXX_Size() int { + return m.Size() +} +func (m *EffectHash) XXX_DiscardUnknown() { + xxx_messageInfo_EffectHash.DiscardUnknown(m) +} + +var xxx_messageInfo_EffectHash proto.InternalMessageInfo + +func (m *EffectHash) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// A transaction ID, the Sha256 hash of a transaction. +// +// This is the hash of the plain byte encoding, used by Tendermint. +type TransactionId struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *TransactionId) Reset() { *m = TransactionId{} } +func (m *TransactionId) String() string { return proto.CompactTextString(m) } +func (*TransactionId) ProtoMessage() {} +func (*TransactionId) Descriptor() ([]byte, []int) { + return fileDescriptor_be98fc5f1d1ce16e, []int{1} +} +func (m *TransactionId) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TransactionId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TransactionId.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 *TransactionId) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionId.Merge(m, src) +} +func (m *TransactionId) XXX_Size() int { + return m.Size() +} +func (m *TransactionId) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionId.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionId proto.InternalMessageInfo + +func (m *TransactionId) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +func init() { + proto.RegisterType((*EffectHash)(nil), "penumbra.core.txhash.v1alpha1.EffectHash") + proto.RegisterType((*TransactionId)(nil), "penumbra.core.txhash.v1alpha1.TransactionId") +} + +func init() { + proto.RegisterFile("penumbra/core/txhash/v1alpha1/txhash.proto", fileDescriptor_be98fc5f1d1ce16e) +} + +var fileDescriptor_be98fc5f1d1ce16e = []byte{ + // 292 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2a, 0x48, 0xcd, 0x2b, + 0xcd, 0x4d, 0x2a, 0x4a, 0xd4, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0x2f, 0xa9, 0xc8, 0x48, 0x2c, 0xce, + 0xd0, 0x2f, 0x33, 0x4c, 0xcc, 0x29, 0xc8, 0x48, 0x34, 0x84, 0xf2, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, + 0xf2, 0x85, 0x64, 0x61, 0x6a, 0xf5, 0x40, 0x6a, 0xf5, 0xa0, 0x72, 0x30, 0xb5, 0x4a, 0x4a, 0x5c, + 0x5c, 0xae, 0x69, 0x69, 0xa9, 0xc9, 0x25, 0x1e, 0x89, 0xc5, 0x19, 0x42, 0x22, 0x5c, 0xac, 0x99, + 0x79, 0x79, 0xa9, 0x45, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c, 0x41, 0x10, 0x8e, 0x92, 0x2a, 0x17, + 0x6f, 0x48, 0x51, 0x62, 0x5e, 0x71, 0x62, 0x72, 0x49, 0x66, 0x7e, 0x9e, 0x67, 0x0a, 0x76, 0x65, + 0x4e, 0x3b, 0x99, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, + 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x81, 0x4b, 0x31, 0x39, + 0x3f, 0x57, 0x0f, 0xaf, 0x43, 0x9c, 0xb8, 0x43, 0xc0, 0x02, 0x01, 0x20, 0x47, 0x07, 0x30, 0x46, + 0x45, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x27, 0xe7, 0x17, 0xe7, + 0xe6, 0x17, 0xeb, 0x17, 0xa5, 0xe6, 0x24, 0x56, 0xa6, 0x16, 0xe9, 0x97, 0x19, 0xc1, 0x99, 0xc9, + 0x19, 0x89, 0x99, 0x79, 0xc5, 0xfa, 0x78, 0x83, 0xc3, 0x1a, 0xc2, 0x87, 0x71, 0x17, 0x31, 0x31, + 0x07, 0x38, 0x87, 0xac, 0x62, 0x92, 0x0d, 0x80, 0x39, 0xc7, 0x19, 0xe4, 0x1c, 0x88, 0xed, 0x7a, + 0x61, 0x50, 0x55, 0xa7, 0x10, 0xf2, 0x31, 0x20, 0xf9, 0x18, 0x88, 0x7c, 0x0c, 0x4c, 0xfe, 0x11, + 0x93, 0x26, 0x5e, 0xf9, 0x18, 0xf7, 0x00, 0x27, 0xdf, 0xd4, 0x92, 0xc4, 0x94, 0xc4, 0x92, 0xc4, + 0x57, 0x4c, 0x0a, 0x30, 0xb5, 0x56, 0x56, 0x20, 0xc5, 0x56, 0x56, 0x10, 0xd5, 0x56, 0x56, 0x30, + 0xe5, 0x49, 0x6c, 0xe0, 0xc8, 0x32, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x59, 0x73, 0x13, 0x3f, + 0xda, 0x01, 0x00, 0x00, +} + +func (m *EffectHash) 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 *EffectHash) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EffectHash) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintTxhash(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TransactionId) 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 *TransactionId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TransactionId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintTxhash(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintTxhash(dAtA []byte, offset int, v uint64) int { + offset -= sovTxhash(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *EffectHash) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovTxhash(uint64(l)) + } + return n +} + +func (m *TransactionId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovTxhash(uint64(l)) + } + return n +} + +func sovTxhash(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTxhash(x uint64) (n int) { + return sovTxhash(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *EffectHash) 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 ErrIntOverflowTxhash + } + 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: EffectHash: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EffectHash: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTxhash + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTxhash + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTxhash + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTxhash(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTxhash + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TransactionId) 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 ErrIntOverflowTxhash + } + 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: TransactionId: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TransactionId: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTxhash + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTxhash + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTxhash + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTxhash(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTxhash + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTxhash(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, ErrIntOverflowTxhash + } + 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, ErrIntOverflowTxhash + } + 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, ErrIntOverflowTxhash + } + 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, ErrInvalidLengthTxhash + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTxhash + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTxhash + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTxhash = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTxhash = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTxhash = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.pb.go b/relayer/chains/penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.pb.go new file mode 100644 index 000000000..7172af1e0 --- /dev/null +++ b/relayer/chains/penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.pb.go @@ -0,0 +1,327 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.proto + +package decaf377_fmdv1alpha1 + +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 + +// A clue for use with Fuzzy Message Detection. +type Clue struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *Clue) Reset() { *m = Clue{} } +func (m *Clue) String() string { return proto.CompactTextString(m) } +func (*Clue) ProtoMessage() {} +func (*Clue) Descriptor() ([]byte, []int) { + return fileDescriptor_5575e9604747910d, []int{0} +} +func (m *Clue) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Clue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Clue.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 *Clue) XXX_Merge(src proto.Message) { + xxx_messageInfo_Clue.Merge(m, src) +} +func (m *Clue) XXX_Size() int { + return m.Size() +} +func (m *Clue) XXX_DiscardUnknown() { + xxx_messageInfo_Clue.DiscardUnknown(m) +} + +var xxx_messageInfo_Clue proto.InternalMessageInfo + +func (m *Clue) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +func init() { + proto.RegisterType((*Clue)(nil), "penumbra.crypto.decaf377_fmd.v1alpha1.Clue") +} + +func init() { + proto.RegisterFile("penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.proto", fileDescriptor_5575e9604747910d) +} + +var fileDescriptor_5575e9604747910d = []byte{ + // 280 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x28, 0x48, 0xcd, 0x2b, + 0xcd, 0x4d, 0x2a, 0x4a, 0xd4, 0x4f, 0x2e, 0xaa, 0x2c, 0x28, 0xc9, 0xd7, 0x4f, 0x49, 0x4d, 0x4e, + 0x4c, 0x33, 0x36, 0x37, 0x8f, 0x4f, 0xcb, 0x4d, 0xd1, 0x2f, 0x33, 0x4c, 0xcc, 0x29, 0xc8, 0x48, + 0x34, 0x44, 0x11, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x85, 0xe9, 0xd4, 0x83, 0xe8, + 0xd4, 0x43, 0x51, 0x03, 0xd3, 0xa9, 0x24, 0xc3, 0xc5, 0xe2, 0x9c, 0x53, 0x9a, 0x2a, 0x24, 0xc2, + 0xc5, 0x9a, 0x99, 0x97, 0x97, 0x5a, 0x24, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x13, 0x04, 0xe1, 0x38, + 0x7d, 0x60, 0x3a, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, + 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x06, 0x2e, 0xcd, 0xe4, 0xfc, + 0x5c, 0x3d, 0xa2, 0xec, 0x70, 0x12, 0x70, 0x81, 0x0a, 0xbb, 0xe5, 0xa6, 0x04, 0x80, 0x1c, 0x17, + 0xc0, 0x18, 0x95, 0x96, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f, 0x9c, + 0x5f, 0x9c, 0x9b, 0x5f, 0xac, 0x5f, 0x94, 0x9a, 0x93, 0x58, 0x99, 0x5a, 0xa4, 0x5f, 0x66, 0x04, + 0x67, 0x26, 0x67, 0x24, 0x66, 0xe6, 0x15, 0xeb, 0x13, 0x15, 0x08, 0xd6, 0xc8, 0xa2, 0x30, 0xc1, + 0x45, 0x4c, 0xcc, 0x01, 0xce, 0x2e, 0xab, 0x98, 0x54, 0x02, 0x60, 0x2e, 0x75, 0x86, 0xb8, 0x14, + 0xc9, 0x49, 0x7a, 0x61, 0x50, 0xc5, 0xa7, 0x10, 0xca, 0x62, 0x20, 0xca, 0x62, 0x90, 0x94, 0xc5, + 0xc0, 0x94, 0x3d, 0x62, 0x32, 0x20, 0x46, 0x59, 0x8c, 0x7b, 0x80, 0x93, 0x6f, 0x6a, 0x49, 0x62, + 0x4a, 0x62, 0x49, 0xe2, 0x2b, 0x26, 0x75, 0x98, 0x16, 0x2b, 0x2b, 0x88, 0x1e, 0x2b, 0x2b, 0x24, + 0x4d, 0x56, 0x56, 0x30, 0x5d, 0x49, 0x6c, 0xe0, 0xe8, 0x33, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, + 0x5b, 0x42, 0x57, 0xa7, 0xfa, 0x01, 0x00, 0x00, +} + +func (m *Clue) 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 *Clue) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Clue) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintDecaf377Fmd(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintDecaf377Fmd(dAtA []byte, offset int, v uint64) int { + offset -= sovDecaf377Fmd(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Clue) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovDecaf377Fmd(uint64(l)) + } + return n +} + +func sovDecaf377Fmd(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozDecaf377Fmd(x uint64) (n int) { + return sovDecaf377Fmd(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Clue) 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 ErrIntOverflowDecaf377Fmd + } + 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: Clue: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Clue: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Fmd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDecaf377Fmd + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Fmd + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Fmd(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Fmd + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipDecaf377Fmd(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, ErrIntOverflowDecaf377Fmd + } + 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, ErrIntOverflowDecaf377Fmd + } + 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, ErrIntOverflowDecaf377Fmd + } + 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, ErrInvalidLengthDecaf377Fmd + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupDecaf377Fmd + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthDecaf377Fmd + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthDecaf377Fmd = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDecaf377Fmd = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupDecaf377Fmd = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.pb.go b/relayer/chains/penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.pb.go new file mode 100644 index 000000000..36bd3d228 --- /dev/null +++ b/relayer/chains/penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.pb.go @@ -0,0 +1,1525 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.proto + +package decaf377_frostv1alpha1 + +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 + +// A commitment to a polynomial, as a list of group elements. +type VerifiableSecretSharingCommitment struct { + // Each of these bytes should be the serialization of a group element. + Elements [][]byte `protobuf:"bytes,1,rep,name=elements,proto3" json:"elements,omitempty"` +} + +func (m *VerifiableSecretSharingCommitment) Reset() { *m = VerifiableSecretSharingCommitment{} } +func (m *VerifiableSecretSharingCommitment) String() string { return proto.CompactTextString(m) } +func (*VerifiableSecretSharingCommitment) ProtoMessage() {} +func (*VerifiableSecretSharingCommitment) Descriptor() ([]byte, []int) { + return fileDescriptor_30ad30621755e0d6, []int{0} +} +func (m *VerifiableSecretSharingCommitment) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *VerifiableSecretSharingCommitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_VerifiableSecretSharingCommitment.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 *VerifiableSecretSharingCommitment) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifiableSecretSharingCommitment.Merge(m, src) +} +func (m *VerifiableSecretSharingCommitment) XXX_Size() int { + return m.Size() +} +func (m *VerifiableSecretSharingCommitment) XXX_DiscardUnknown() { + xxx_messageInfo_VerifiableSecretSharingCommitment.DiscardUnknown(m) +} + +var xxx_messageInfo_VerifiableSecretSharingCommitment proto.InternalMessageInfo + +func (m *VerifiableSecretSharingCommitment) GetElements() [][]byte { + if m != nil { + return m.Elements + } + return nil +} + +// The public package sent in round 1 of the DKG protocol. +type DKGRound1Package struct { + // A commitment to the polynomial for secret sharing. + Commitment *VerifiableSecretSharingCommitment `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"` + // A proof of knowledge of the underlying secret being shared. + ProofOfKnowledge []byte `protobuf:"bytes,2,opt,name=proof_of_knowledge,json=proofOfKnowledge,proto3" json:"proof_of_knowledge,omitempty"` +} + +func (m *DKGRound1Package) Reset() { *m = DKGRound1Package{} } +func (m *DKGRound1Package) String() string { return proto.CompactTextString(m) } +func (*DKGRound1Package) ProtoMessage() {} +func (*DKGRound1Package) Descriptor() ([]byte, []int) { + return fileDescriptor_30ad30621755e0d6, []int{1} +} +func (m *DKGRound1Package) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DKGRound1Package) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DKGRound1Package.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 *DKGRound1Package) XXX_Merge(src proto.Message) { + xxx_messageInfo_DKGRound1Package.Merge(m, src) +} +func (m *DKGRound1Package) XXX_Size() int { + return m.Size() +} +func (m *DKGRound1Package) XXX_DiscardUnknown() { + xxx_messageInfo_DKGRound1Package.DiscardUnknown(m) +} + +var xxx_messageInfo_DKGRound1Package proto.InternalMessageInfo + +func (m *DKGRound1Package) GetCommitment() *VerifiableSecretSharingCommitment { + if m != nil { + return m.Commitment + } + return nil +} + +func (m *DKGRound1Package) GetProofOfKnowledge() []byte { + if m != nil { + return m.ProofOfKnowledge + } + return nil +} + +// A share of the final signing key. +type SigningShare struct { + // These bytes should be a valid scalar. + Scalar []byte `protobuf:"bytes,1,opt,name=scalar,proto3" json:"scalar,omitempty"` +} + +func (m *SigningShare) Reset() { *m = SigningShare{} } +func (m *SigningShare) String() string { return proto.CompactTextString(m) } +func (*SigningShare) ProtoMessage() {} +func (*SigningShare) Descriptor() ([]byte, []int) { + return fileDescriptor_30ad30621755e0d6, []int{2} +} +func (m *SigningShare) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SigningShare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SigningShare.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 *SigningShare) XXX_Merge(src proto.Message) { + xxx_messageInfo_SigningShare.Merge(m, src) +} +func (m *SigningShare) XXX_Size() int { + return m.Size() +} +func (m *SigningShare) XXX_DiscardUnknown() { + xxx_messageInfo_SigningShare.DiscardUnknown(m) +} + +var xxx_messageInfo_SigningShare proto.InternalMessageInfo + +func (m *SigningShare) GetScalar() []byte { + if m != nil { + return m.Scalar + } + return nil +} + +// The per-participant package sent in round 2 of the DKG protocol. +type DKGRound2Package struct { + // This is the share we're sending to that participant. + SigningShare *SigningShare `protobuf:"bytes,1,opt,name=signing_share,json=signingShare,proto3" json:"signing_share,omitempty"` +} + +func (m *DKGRound2Package) Reset() { *m = DKGRound2Package{} } +func (m *DKGRound2Package) String() string { return proto.CompactTextString(m) } +func (*DKGRound2Package) ProtoMessage() {} +func (*DKGRound2Package) Descriptor() ([]byte, []int) { + return fileDescriptor_30ad30621755e0d6, []int{3} +} +func (m *DKGRound2Package) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DKGRound2Package) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DKGRound2Package.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 *DKGRound2Package) XXX_Merge(src proto.Message) { + xxx_messageInfo_DKGRound2Package.Merge(m, src) +} +func (m *DKGRound2Package) XXX_Size() int { + return m.Size() +} +func (m *DKGRound2Package) XXX_DiscardUnknown() { + xxx_messageInfo_DKGRound2Package.DiscardUnknown(m) +} + +var xxx_messageInfo_DKGRound2Package proto.InternalMessageInfo + +func (m *DKGRound2Package) GetSigningShare() *SigningShare { + if m != nil { + return m.SigningShare + } + return nil +} + +// Represents a commitment to a nonce value. +type NonceCommitment struct { + // These bytes should be a valid group element. + Element []byte `protobuf:"bytes,1,opt,name=element,proto3" json:"element,omitempty"` +} + +func (m *NonceCommitment) Reset() { *m = NonceCommitment{} } +func (m *NonceCommitment) String() string { return proto.CompactTextString(m) } +func (*NonceCommitment) ProtoMessage() {} +func (*NonceCommitment) Descriptor() ([]byte, []int) { + return fileDescriptor_30ad30621755e0d6, []int{4} +} +func (m *NonceCommitment) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NonceCommitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NonceCommitment.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 *NonceCommitment) XXX_Merge(src proto.Message) { + xxx_messageInfo_NonceCommitment.Merge(m, src) +} +func (m *NonceCommitment) XXX_Size() int { + return m.Size() +} +func (m *NonceCommitment) XXX_DiscardUnknown() { + xxx_messageInfo_NonceCommitment.DiscardUnknown(m) +} + +var xxx_messageInfo_NonceCommitment proto.InternalMessageInfo + +func (m *NonceCommitment) GetElement() []byte { + if m != nil { + return m.Element + } + return nil +} + +// Represents the commitments to nonces needed for signing. +type SigningCommitments struct { + // One nonce to hide them. + Hiding *NonceCommitment `protobuf:"bytes,1,opt,name=hiding,proto3" json:"hiding,omitempty"` + // Another to bind them. + Binding *NonceCommitment `protobuf:"bytes,2,opt,name=binding,proto3" json:"binding,omitempty"` +} + +func (m *SigningCommitments) Reset() { *m = SigningCommitments{} } +func (m *SigningCommitments) String() string { return proto.CompactTextString(m) } +func (*SigningCommitments) ProtoMessage() {} +func (*SigningCommitments) Descriptor() ([]byte, []int) { + return fileDescriptor_30ad30621755e0d6, []int{5} +} +func (m *SigningCommitments) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SigningCommitments) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SigningCommitments.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 *SigningCommitments) XXX_Merge(src proto.Message) { + xxx_messageInfo_SigningCommitments.Merge(m, src) +} +func (m *SigningCommitments) XXX_Size() int { + return m.Size() +} +func (m *SigningCommitments) XXX_DiscardUnknown() { + xxx_messageInfo_SigningCommitments.DiscardUnknown(m) +} + +var xxx_messageInfo_SigningCommitments proto.InternalMessageInfo + +func (m *SigningCommitments) GetHiding() *NonceCommitment { + if m != nil { + return m.Hiding + } + return nil +} + +func (m *SigningCommitments) GetBinding() *NonceCommitment { + if m != nil { + return m.Binding + } + return nil +} + +// A share of the final signature. These get aggregated to make the actual thing. +type SignatureShare struct { + // These bytes should be a valid scalar. + Scalar []byte `protobuf:"bytes,1,opt,name=scalar,proto3" json:"scalar,omitempty"` +} + +func (m *SignatureShare) Reset() { *m = SignatureShare{} } +func (m *SignatureShare) String() string { return proto.CompactTextString(m) } +func (*SignatureShare) ProtoMessage() {} +func (*SignatureShare) Descriptor() ([]byte, []int) { + return fileDescriptor_30ad30621755e0d6, []int{6} +} +func (m *SignatureShare) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SignatureShare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SignatureShare.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 *SignatureShare) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignatureShare.Merge(m, src) +} +func (m *SignatureShare) XXX_Size() int { + return m.Size() +} +func (m *SignatureShare) XXX_DiscardUnknown() { + xxx_messageInfo_SignatureShare.DiscardUnknown(m) +} + +var xxx_messageInfo_SignatureShare proto.InternalMessageInfo + +func (m *SignatureShare) GetScalar() []byte { + if m != nil { + return m.Scalar + } + return nil +} + +func init() { + proto.RegisterType((*VerifiableSecretSharingCommitment)(nil), "penumbra.crypto.decaf377_frost.v1alpha1.VerifiableSecretSharingCommitment") + proto.RegisterType((*DKGRound1Package)(nil), "penumbra.crypto.decaf377_frost.v1alpha1.DKGRound1Package") + proto.RegisterType((*SigningShare)(nil), "penumbra.crypto.decaf377_frost.v1alpha1.SigningShare") + proto.RegisterType((*DKGRound2Package)(nil), "penumbra.crypto.decaf377_frost.v1alpha1.DKGRound2Package") + proto.RegisterType((*NonceCommitment)(nil), "penumbra.crypto.decaf377_frost.v1alpha1.NonceCommitment") + proto.RegisterType((*SigningCommitments)(nil), "penumbra.crypto.decaf377_frost.v1alpha1.SigningCommitments") + proto.RegisterType((*SignatureShare)(nil), "penumbra.crypto.decaf377_frost.v1alpha1.SignatureShare") +} + +func init() { + proto.RegisterFile("penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.proto", fileDescriptor_30ad30621755e0d6) +} + +var fileDescriptor_30ad30621755e0d6 = []byte{ + // 518 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x4f, 0x8b, 0x13, 0x31, + 0x18, 0xc6, 0x9b, 0x29, 0x74, 0x25, 0x56, 0x5d, 0x72, 0x90, 0xe2, 0x61, 0xa8, 0x73, 0x58, 0x2b, + 0x2b, 0x33, 0xb4, 0x8b, 0xac, 0x8c, 0x82, 0xd0, 0x16, 0x17, 0x5c, 0xd4, 0x61, 0x0a, 0x7b, 0x58, + 0x0a, 0x25, 0x4d, 0x33, 0xd3, 0xec, 0xce, 0x24, 0x25, 0x49, 0x57, 0xf6, 0xe6, 0x47, 0xf0, 0x33, + 0x78, 0x14, 0x3f, 0x81, 0x9f, 0x40, 0x3c, 0xed, 0xd1, 0xa3, 0xb4, 0x37, 0x3f, 0x85, 0x4c, 0x3b, + 0xe9, 0xbf, 0x83, 0x0e, 0xec, 0x2d, 0xef, 0x9b, 0xe7, 0x79, 0xf2, 0x7b, 0x33, 0x64, 0xe0, 0xab, + 0x09, 0xe5, 0xd3, 0x74, 0x28, 0xb1, 0x47, 0xe4, 0xf5, 0x44, 0x0b, 0x6f, 0x44, 0x09, 0x8e, 0x8e, + 0x8e, 0x8f, 0x07, 0x91, 0x14, 0x4a, 0x7b, 0x57, 0x4d, 0x9c, 0x4c, 0xc6, 0xb8, 0xb9, 0xd3, 0x77, + 0x27, 0x52, 0x68, 0x81, 0x9e, 0x18, 0xb7, 0xbb, 0x74, 0xbb, 0x3b, 0x2a, 0xe3, 0x76, 0x5e, 0xc3, + 0xc7, 0x67, 0x54, 0xb2, 0x88, 0xe1, 0x61, 0x42, 0x7b, 0x94, 0x48, 0xaa, 0x7b, 0x63, 0x2c, 0x19, + 0x8f, 0x3b, 0x22, 0x4d, 0x99, 0x4e, 0x29, 0xd7, 0xe8, 0x11, 0xbc, 0x43, 0x13, 0x9a, 0x2d, 0x55, + 0x0d, 0xd4, 0xcb, 0x8d, 0x6a, 0xb8, 0xaa, 0x9d, 0x6f, 0x00, 0xee, 0x77, 0x4f, 0x4f, 0x42, 0x31, + 0xe5, 0xa3, 0x66, 0x80, 0xc9, 0x25, 0x8e, 0x29, 0xba, 0x80, 0x90, 0xac, 0xec, 0x35, 0x50, 0x07, + 0x8d, 0xbb, 0xad, 0xb7, 0x6e, 0x41, 0x26, 0xf7, 0xbf, 0x40, 0xe1, 0x46, 0x3a, 0x7a, 0x06, 0xd1, + 0x44, 0x0a, 0x11, 0x0d, 0x44, 0x34, 0xb8, 0xe4, 0xe2, 0x63, 0x42, 0x47, 0x31, 0xad, 0x59, 0x75, + 0xd0, 0xa8, 0x86, 0xfb, 0x8b, 0x9d, 0x0f, 0xd1, 0xa9, 0xe9, 0x3b, 0x07, 0xb0, 0xda, 0x63, 0x31, + 0x67, 0x3c, 0xce, 0x52, 0x29, 0x7a, 0x08, 0x2b, 0x8a, 0xe0, 0x04, 0xcb, 0x05, 0x65, 0x35, 0xcc, + 0x2b, 0x87, 0xaf, 0xa7, 0x6a, 0x99, 0xa9, 0xce, 0xe1, 0x3d, 0xb5, 0xf4, 0x0e, 0x54, 0x66, 0xce, + 0x07, 0x7b, 0x5e, 0x78, 0xb0, 0xcd, 0x93, 0xc3, 0xaa, 0xda, 0xa8, 0x9c, 0x43, 0xf8, 0xe0, 0xbd, + 0xe0, 0x84, 0x6e, 0xdc, 0x7a, 0x0d, 0xee, 0xe5, 0xb7, 0x9c, 0xb3, 0x99, 0xd2, 0xf9, 0x0e, 0x20, + 0xca, 0xb3, 0xd6, 0x7a, 0x85, 0x02, 0x58, 0x19, 0xb3, 0x11, 0xe3, 0x71, 0x0e, 0xf6, 0xa2, 0x30, + 0xd8, 0xce, 0xd1, 0x61, 0x9e, 0x83, 0x42, 0xb8, 0x37, 0x64, 0x7c, 0x11, 0x69, 0xdd, 0x32, 0xd2, + 0x04, 0x39, 0x0d, 0x78, 0x3f, 0x63, 0xc7, 0x7a, 0x2a, 0xe9, 0x3f, 0xbf, 0x41, 0xfb, 0x53, 0xf9, + 0xc7, 0xcc, 0x06, 0x37, 0x33, 0x1b, 0xfc, 0x9e, 0xd9, 0xe0, 0xf3, 0xdc, 0x2e, 0xdd, 0xcc, 0xed, + 0xd2, 0xaf, 0xb9, 0x5d, 0x82, 0x87, 0x44, 0xa4, 0x45, 0x51, 0xda, 0xa8, 0x9b, 0x6f, 0xbc, 0xc9, + 0xfa, 0x41, 0xf6, 0x40, 0x02, 0x70, 0x7e, 0x11, 0x33, 0x3d, 0x9e, 0x0e, 0x5d, 0x22, 0x52, 0x8f, + 0x08, 0x95, 0x0a, 0xe5, 0x49, 0x9a, 0xe0, 0x6b, 0x2a, 0xbd, 0xab, 0xd6, 0x6a, 0x49, 0xc6, 0x98, + 0x71, 0xe5, 0x15, 0x7c, 0x8c, 0x2f, 0xb7, 0xfb, 0xa6, 0xfd, 0xc5, 0x2a, 0x07, 0x9d, 0xee, 0x57, + 0xeb, 0x20, 0x30, 0xc4, 0x9d, 0x25, 0xf1, 0x16, 0x98, 0x7b, 0x96, 0xcb, 0x7f, 0xae, 0x85, 0xfd, + 0xa5, 0xb0, 0xbf, 0x25, 0xec, 0x1b, 0xe1, 0xcc, 0x6a, 0x15, 0x13, 0xf6, 0x4f, 0x82, 0xf6, 0x3b, + 0xaa, 0xf1, 0x08, 0x6b, 0xfc, 0xc7, 0x7a, 0x6a, 0x4c, 0xbe, 0xbf, 0x74, 0xf9, 0xfe, 0x96, 0xcd, + 0xf7, 0x8d, 0x6f, 0x58, 0x59, 0xfc, 0x4e, 0x8e, 0xfe, 0x06, 0x00, 0x00, 0xff, 0xff, 0x01, 0xef, + 0xb3, 0x04, 0x8e, 0x04, 0x00, 0x00, +} + +func (m *VerifiableSecretSharingCommitment) 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 *VerifiableSecretSharingCommitment) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifiableSecretSharingCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Elements) > 0 { + for iNdEx := len(m.Elements) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Elements[iNdEx]) + copy(dAtA[i:], m.Elements[iNdEx]) + i = encodeVarintDecaf377Frost(dAtA, i, uint64(len(m.Elements[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *DKGRound1Package) 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 *DKGRound1Package) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DKGRound1Package) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ProofOfKnowledge) > 0 { + i -= len(m.ProofOfKnowledge) + copy(dAtA[i:], m.ProofOfKnowledge) + i = encodeVarintDecaf377Frost(dAtA, i, uint64(len(m.ProofOfKnowledge))) + i-- + dAtA[i] = 0x12 + } + if m.Commitment != nil { + { + size, err := m.Commitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDecaf377Frost(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SigningShare) 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 *SigningShare) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SigningShare) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Scalar) > 0 { + i -= len(m.Scalar) + copy(dAtA[i:], m.Scalar) + i = encodeVarintDecaf377Frost(dAtA, i, uint64(len(m.Scalar))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DKGRound2Package) 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 *DKGRound2Package) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DKGRound2Package) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SigningShare != nil { + { + size, err := m.SigningShare.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDecaf377Frost(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *NonceCommitment) 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 *NonceCommitment) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NonceCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Element) > 0 { + i -= len(m.Element) + copy(dAtA[i:], m.Element) + i = encodeVarintDecaf377Frost(dAtA, i, uint64(len(m.Element))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SigningCommitments) 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 *SigningCommitments) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SigningCommitments) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Binding != nil { + { + size, err := m.Binding.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDecaf377Frost(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Hiding != nil { + { + size, err := m.Hiding.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDecaf377Frost(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignatureShare) 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 *SignatureShare) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignatureShare) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Scalar) > 0 { + i -= len(m.Scalar) + copy(dAtA[i:], m.Scalar) + i = encodeVarintDecaf377Frost(dAtA, i, uint64(len(m.Scalar))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintDecaf377Frost(dAtA []byte, offset int, v uint64) int { + offset -= sovDecaf377Frost(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *VerifiableSecretSharingCommitment) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Elements) > 0 { + for _, b := range m.Elements { + l = len(b) + n += 1 + l + sovDecaf377Frost(uint64(l)) + } + } + return n +} + +func (m *DKGRound1Package) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Commitment != nil { + l = m.Commitment.Size() + n += 1 + l + sovDecaf377Frost(uint64(l)) + } + l = len(m.ProofOfKnowledge) + if l > 0 { + n += 1 + l + sovDecaf377Frost(uint64(l)) + } + return n +} + +func (m *SigningShare) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Scalar) + if l > 0 { + n += 1 + l + sovDecaf377Frost(uint64(l)) + } + return n +} + +func (m *DKGRound2Package) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SigningShare != nil { + l = m.SigningShare.Size() + n += 1 + l + sovDecaf377Frost(uint64(l)) + } + return n +} + +func (m *NonceCommitment) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Element) + if l > 0 { + n += 1 + l + sovDecaf377Frost(uint64(l)) + } + return n +} + +func (m *SigningCommitments) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Hiding != nil { + l = m.Hiding.Size() + n += 1 + l + sovDecaf377Frost(uint64(l)) + } + if m.Binding != nil { + l = m.Binding.Size() + n += 1 + l + sovDecaf377Frost(uint64(l)) + } + return n +} + +func (m *SignatureShare) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Scalar) + if l > 0 { + n += 1 + l + sovDecaf377Frost(uint64(l)) + } + return n +} + +func sovDecaf377Frost(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozDecaf377Frost(x uint64) (n int) { + return sovDecaf377Frost(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *VerifiableSecretSharingCommitment) 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 ErrIntOverflowDecaf377Frost + } + 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: VerifiableSecretSharingCommitment: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VerifiableSecretSharingCommitment: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Elements", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Frost + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDecaf377Frost + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Frost + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Elements = append(m.Elements, make([]byte, postIndex-iNdEx)) + copy(m.Elements[len(m.Elements)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Frost(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Frost + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DKGRound1Package) 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 ErrIntOverflowDecaf377Frost + } + 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: DKGRound1Package: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DKGRound1Package: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Frost + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDecaf377Frost + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Frost + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Commitment == nil { + m.Commitment = &VerifiableSecretSharingCommitment{} + } + if err := m.Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofOfKnowledge", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Frost + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDecaf377Frost + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Frost + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofOfKnowledge = append(m.ProofOfKnowledge[:0], dAtA[iNdEx:postIndex]...) + if m.ProofOfKnowledge == nil { + m.ProofOfKnowledge = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Frost(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Frost + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SigningShare) 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 ErrIntOverflowDecaf377Frost + } + 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: SigningShare: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SigningShare: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Scalar", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Frost + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDecaf377Frost + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Frost + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Scalar = append(m.Scalar[:0], dAtA[iNdEx:postIndex]...) + if m.Scalar == nil { + m.Scalar = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Frost(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Frost + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DKGRound2Package) 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 ErrIntOverflowDecaf377Frost + } + 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: DKGRound2Package: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DKGRound2Package: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SigningShare", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Frost + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDecaf377Frost + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Frost + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SigningShare == nil { + m.SigningShare = &SigningShare{} + } + if err := m.SigningShare.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Frost(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Frost + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NonceCommitment) 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 ErrIntOverflowDecaf377Frost + } + 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: NonceCommitment: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NonceCommitment: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Element", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Frost + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDecaf377Frost + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Frost + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Element = append(m.Element[:0], dAtA[iNdEx:postIndex]...) + if m.Element == nil { + m.Element = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Frost(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Frost + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SigningCommitments) 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 ErrIntOverflowDecaf377Frost + } + 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: SigningCommitments: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SigningCommitments: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hiding", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Frost + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDecaf377Frost + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Frost + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Hiding == nil { + m.Hiding = &NonceCommitment{} + } + if err := m.Hiding.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Binding", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Frost + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDecaf377Frost + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Frost + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Binding == nil { + m.Binding = &NonceCommitment{} + } + if err := m.Binding.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Frost(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Frost + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignatureShare) 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 ErrIntOverflowDecaf377Frost + } + 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: SignatureShare: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignatureShare: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Scalar", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Frost + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDecaf377Frost + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Frost + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Scalar = append(m.Scalar[:0], dAtA[iNdEx:postIndex]...) + if m.Scalar == nil { + m.Scalar = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Frost(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Frost + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipDecaf377Frost(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, ErrIntOverflowDecaf377Frost + } + 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, ErrIntOverflowDecaf377Frost + } + 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, ErrIntOverflowDecaf377Frost + } + 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, ErrInvalidLengthDecaf377Frost + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupDecaf377Frost + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthDecaf377Frost + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthDecaf377Frost = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDecaf377Frost = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupDecaf377Frost = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.pb.go b/relayer/chains/penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.pb.go new file mode 100644 index 000000000..512f905e6 --- /dev/null +++ b/relayer/chains/penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.pb.go @@ -0,0 +1,673 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.proto + +package decaf377_rdsav1alpha1 + +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 + +type SpendAuthSignature struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *SpendAuthSignature) Reset() { *m = SpendAuthSignature{} } +func (m *SpendAuthSignature) String() string { return proto.CompactTextString(m) } +func (*SpendAuthSignature) ProtoMessage() {} +func (*SpendAuthSignature) Descriptor() ([]byte, []int) { + return fileDescriptor_5769d4d01f5df277, []int{0} +} +func (m *SpendAuthSignature) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpendAuthSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpendAuthSignature.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 *SpendAuthSignature) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpendAuthSignature.Merge(m, src) +} +func (m *SpendAuthSignature) XXX_Size() int { + return m.Size() +} +func (m *SpendAuthSignature) XXX_DiscardUnknown() { + xxx_messageInfo_SpendAuthSignature.DiscardUnknown(m) +} + +var xxx_messageInfo_SpendAuthSignature proto.InternalMessageInfo + +func (m *SpendAuthSignature) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +type BindingSignature struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *BindingSignature) Reset() { *m = BindingSignature{} } +func (m *BindingSignature) String() string { return proto.CompactTextString(m) } +func (*BindingSignature) ProtoMessage() {} +func (*BindingSignature) Descriptor() ([]byte, []int) { + return fileDescriptor_5769d4d01f5df277, []int{1} +} +func (m *BindingSignature) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BindingSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BindingSignature.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 *BindingSignature) XXX_Merge(src proto.Message) { + xxx_messageInfo_BindingSignature.Merge(m, src) +} +func (m *BindingSignature) XXX_Size() int { + return m.Size() +} +func (m *BindingSignature) XXX_DiscardUnknown() { + xxx_messageInfo_BindingSignature.DiscardUnknown(m) +} + +var xxx_messageInfo_BindingSignature proto.InternalMessageInfo + +func (m *BindingSignature) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +type SpendVerificationKey struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *SpendVerificationKey) Reset() { *m = SpendVerificationKey{} } +func (m *SpendVerificationKey) String() string { return proto.CompactTextString(m) } +func (*SpendVerificationKey) ProtoMessage() {} +func (*SpendVerificationKey) Descriptor() ([]byte, []int) { + return fileDescriptor_5769d4d01f5df277, []int{2} +} +func (m *SpendVerificationKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpendVerificationKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpendVerificationKey.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 *SpendVerificationKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpendVerificationKey.Merge(m, src) +} +func (m *SpendVerificationKey) XXX_Size() int { + return m.Size() +} +func (m *SpendVerificationKey) XXX_DiscardUnknown() { + xxx_messageInfo_SpendVerificationKey.DiscardUnknown(m) +} + +var xxx_messageInfo_SpendVerificationKey proto.InternalMessageInfo + +func (m *SpendVerificationKey) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +func init() { + proto.RegisterType((*SpendAuthSignature)(nil), "penumbra.crypto.decaf377_rdsa.v1alpha1.SpendAuthSignature") + proto.RegisterType((*BindingSignature)(nil), "penumbra.crypto.decaf377_rdsa.v1alpha1.BindingSignature") + proto.RegisterType((*SpendVerificationKey)(nil), "penumbra.crypto.decaf377_rdsa.v1alpha1.SpendVerificationKey") +} + +func init() { + proto.RegisterFile("penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.proto", fileDescriptor_5769d4d01f5df277) +} + +var fileDescriptor_5769d4d01f5df277 = []byte{ + // 332 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xb1, 0x4a, 0x03, 0x31, + 0x18, 0xc7, 0x7b, 0x27, 0x3a, 0x1c, 0x0e, 0x5a, 0x3a, 0x38, 0x1d, 0x52, 0x50, 0x4a, 0x91, 0x84, + 0xda, 0xa1, 0x10, 0x27, 0xaf, 0x05, 0x07, 0x11, 0x8e, 0x16, 0x3a, 0xc8, 0x81, 0x7c, 0x4d, 0xd2, + 0x5e, 0xa0, 0x97, 0x1c, 0xb9, 0x5c, 0xa1, 0x6f, 0xe1, 0x33, 0x38, 0xfa, 0x24, 0xe2, 0xd4, 0xd1, + 0x51, 0xae, 0x9b, 0x4f, 0xe0, 0x28, 0xf6, 0x1a, 0x6d, 0x41, 0xb0, 0x5b, 0xf2, 0xe7, 0xf7, 0x0b, + 0xff, 0x7c, 0x7c, 0x1e, 0x49, 0xb9, 0xcc, 0x93, 0x91, 0x06, 0x4c, 0xf5, 0x3c, 0x35, 0x0a, 0x33, + 0x4e, 0x61, 0xdc, 0xee, 0x74, 0x1e, 0x34, 0xcb, 0x00, 0xcf, 0x5a, 0x30, 0x4d, 0x63, 0x68, 0x6d, + 0xc7, 0x28, 0xd5, 0xca, 0xa8, 0xea, 0xb9, 0x75, 0x51, 0xe9, 0xa2, 0x6d, 0xc8, 0xba, 0xf5, 0xa6, + 0x57, 0x1d, 0xa4, 0x5c, 0xb2, 0xeb, 0xdc, 0xc4, 0x03, 0x31, 0x91, 0x60, 0x72, 0xcd, 0xab, 0x35, + 0x6f, 0x5f, 0x48, 0xc9, 0xf5, 0x89, 0x73, 0xea, 0x34, 0x0e, 0xfb, 0xe5, 0xa5, 0xde, 0xf0, 0x8e, + 0x02, 0x21, 0x99, 0x90, 0x93, 0xff, 0xc8, 0x0b, 0xaf, 0xb6, 0x7a, 0x75, 0xc8, 0xb5, 0x18, 0x0b, + 0x0a, 0x46, 0x28, 0x79, 0xcb, 0xe7, 0x7f, 0xd3, 0xc1, 0xa7, 0xfb, 0x52, 0xf8, 0xce, 0xa2, 0xf0, + 0x9d, 0xf7, 0xc2, 0x77, 0x1e, 0x97, 0x7e, 0x65, 0xb1, 0xf4, 0x2b, 0x6f, 0x4b, 0xbf, 0xe2, 0x35, + 0xa9, 0x4a, 0xd0, 0x6e, 0x5f, 0x09, 0x8e, 0x7b, 0xeb, 0xbc, 0xcf, 0x32, 0x08, 0xbf, 0xa7, 0x10, + 0x3a, 0xf7, 0xf1, 0x44, 0x98, 0x38, 0x1f, 0x21, 0xaa, 0x12, 0x4c, 0x55, 0x96, 0xa8, 0x0c, 0x6b, + 0x3e, 0x85, 0x39, 0xd7, 0x78, 0x76, 0xf9, 0x73, 0xa4, 0x31, 0x08, 0x99, 0xe1, 0xdd, 0xe6, 0x7d, + 0xb5, 0x15, 0xdb, 0xf4, 0xc9, 0xdd, 0x0b, 0xbb, 0xbd, 0x67, 0xf7, 0x2c, 0xb4, 0x6d, 0xbb, 0x65, + 0xdb, 0xcd, 0x56, 0x68, 0xb8, 0xa6, 0x5f, 0x7f, 0xb9, 0xa8, 0xe4, 0xa2, 0x4d, 0x2e, 0xb2, 0x5c, + 0xe1, 0xb6, 0x76, 0xe2, 0xa2, 0x9b, 0x30, 0xb8, 0xe3, 0x06, 0x18, 0x18, 0xf8, 0x70, 0x1b, 0xd6, + 0x21, 0xa4, 0x94, 0x08, 0xd9, 0xb4, 0x08, 0xb1, 0xda, 0xe8, 0x60, 0xb5, 0x2d, 0xed, 0xaf, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x34, 0x9a, 0xf4, 0x33, 0x6b, 0x02, 0x00, 0x00, +} + +func (m *SpendAuthSignature) 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 *SpendAuthSignature) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendAuthSignature) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintDecaf377Rdsa(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BindingSignature) 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 *BindingSignature) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BindingSignature) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintDecaf377Rdsa(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SpendVerificationKey) 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 *SpendVerificationKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpendVerificationKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintDecaf377Rdsa(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintDecaf377Rdsa(dAtA []byte, offset int, v uint64) int { + offset -= sovDecaf377Rdsa(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *SpendAuthSignature) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovDecaf377Rdsa(uint64(l)) + } + return n +} + +func (m *BindingSignature) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovDecaf377Rdsa(uint64(l)) + } + return n +} + +func (m *SpendVerificationKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovDecaf377Rdsa(uint64(l)) + } + return n +} + +func sovDecaf377Rdsa(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozDecaf377Rdsa(x uint64) (n int) { + return sovDecaf377Rdsa(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *SpendAuthSignature) 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 ErrIntOverflowDecaf377Rdsa + } + 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: SpendAuthSignature: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpendAuthSignature: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Rdsa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDecaf377Rdsa + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Rdsa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Rdsa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Rdsa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BindingSignature) 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 ErrIntOverflowDecaf377Rdsa + } + 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: BindingSignature: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BindingSignature: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Rdsa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDecaf377Rdsa + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Rdsa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Rdsa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Rdsa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpendVerificationKey) 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 ErrIntOverflowDecaf377Rdsa + } + 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: SpendVerificationKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpendVerificationKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDecaf377Rdsa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDecaf377Rdsa + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDecaf377Rdsa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDecaf377Rdsa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDecaf377Rdsa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipDecaf377Rdsa(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, ErrIntOverflowDecaf377Rdsa + } + 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, ErrIntOverflowDecaf377Rdsa + } + 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, ErrIntOverflowDecaf377Rdsa + } + 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, ErrInvalidLengthDecaf377Rdsa + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupDecaf377Rdsa + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthDecaf377Rdsa + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthDecaf377Rdsa = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDecaf377Rdsa = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupDecaf377Rdsa = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/crypto/tct/v1alpha1/tct.pb.go b/relayer/chains/penumbra/crypto/tct/v1alpha1/tct.pb.go new file mode 100644 index 000000000..bb44d538d --- /dev/null +++ b/relayer/chains/penumbra/crypto/tct/v1alpha1/tct.pb.go @@ -0,0 +1,1063 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/crypto/tct/v1alpha1/tct.proto + +package tctv1alpha1 + +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 + +type StateCommitment struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *StateCommitment) Reset() { *m = StateCommitment{} } +func (m *StateCommitment) String() string { return proto.CompactTextString(m) } +func (*StateCommitment) ProtoMessage() {} +func (*StateCommitment) Descriptor() ([]byte, []int) { + return fileDescriptor_7a94190b2b9c1621, []int{0} +} +func (m *StateCommitment) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StateCommitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StateCommitment.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 *StateCommitment) XXX_Merge(src proto.Message) { + xxx_messageInfo_StateCommitment.Merge(m, src) +} +func (m *StateCommitment) XXX_Size() int { + return m.Size() +} +func (m *StateCommitment) XXX_DiscardUnknown() { + xxx_messageInfo_StateCommitment.DiscardUnknown(m) +} + +var xxx_messageInfo_StateCommitment proto.InternalMessageInfo + +func (m *StateCommitment) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +type MerkleRoot struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *MerkleRoot) Reset() { *m = MerkleRoot{} } +func (m *MerkleRoot) String() string { return proto.CompactTextString(m) } +func (*MerkleRoot) ProtoMessage() {} +func (*MerkleRoot) Descriptor() ([]byte, []int) { + return fileDescriptor_7a94190b2b9c1621, []int{1} +} +func (m *MerkleRoot) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MerkleRoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MerkleRoot.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 *MerkleRoot) XXX_Merge(src proto.Message) { + xxx_messageInfo_MerkleRoot.Merge(m, src) +} +func (m *MerkleRoot) XXX_Size() int { + return m.Size() +} +func (m *MerkleRoot) XXX_DiscardUnknown() { + xxx_messageInfo_MerkleRoot.DiscardUnknown(m) +} + +var xxx_messageInfo_MerkleRoot proto.InternalMessageInfo + +func (m *MerkleRoot) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// An authentication path from a state commitment to the root of the state commitment tree. +type StateCommitmentProof struct { + NoteCommitment *StateCommitment `protobuf:"bytes,1,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` + Position uint64 `protobuf:"varint,2,opt,name=position,proto3" json:"position,omitempty"` + AuthPath []*MerklePathChunk `protobuf:"bytes,3,rep,name=auth_path,json=authPath,proto3" json:"auth_path,omitempty"` +} + +func (m *StateCommitmentProof) Reset() { *m = StateCommitmentProof{} } +func (m *StateCommitmentProof) String() string { return proto.CompactTextString(m) } +func (*StateCommitmentProof) ProtoMessage() {} +func (*StateCommitmentProof) Descriptor() ([]byte, []int) { + return fileDescriptor_7a94190b2b9c1621, []int{2} +} +func (m *StateCommitmentProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StateCommitmentProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StateCommitmentProof.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 *StateCommitmentProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_StateCommitmentProof.Merge(m, src) +} +func (m *StateCommitmentProof) XXX_Size() int { + return m.Size() +} +func (m *StateCommitmentProof) XXX_DiscardUnknown() { + xxx_messageInfo_StateCommitmentProof.DiscardUnknown(m) +} + +var xxx_messageInfo_StateCommitmentProof proto.InternalMessageInfo + +func (m *StateCommitmentProof) GetNoteCommitment() *StateCommitment { + if m != nil { + return m.NoteCommitment + } + return nil +} + +func (m *StateCommitmentProof) GetPosition() uint64 { + if m != nil { + return m.Position + } + return 0 +} + +func (m *StateCommitmentProof) GetAuthPath() []*MerklePathChunk { + if m != nil { + return m.AuthPath + } + return nil +} + +// A set of 3 sibling hashes in the auth path for some note commitment. +type MerklePathChunk struct { + Sibling_1 []byte `protobuf:"bytes,1,opt,name=sibling_1,json=sibling1,proto3" json:"sibling_1,omitempty"` + Sibling_2 []byte `protobuf:"bytes,2,opt,name=sibling_2,json=sibling2,proto3" json:"sibling_2,omitempty"` + Sibling_3 []byte `protobuf:"bytes,3,opt,name=sibling_3,json=sibling3,proto3" json:"sibling_3,omitempty"` +} + +func (m *MerklePathChunk) Reset() { *m = MerklePathChunk{} } +func (m *MerklePathChunk) String() string { return proto.CompactTextString(m) } +func (*MerklePathChunk) ProtoMessage() {} +func (*MerklePathChunk) Descriptor() ([]byte, []int) { + return fileDescriptor_7a94190b2b9c1621, []int{3} +} +func (m *MerklePathChunk) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MerklePathChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MerklePathChunk.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 *MerklePathChunk) XXX_Merge(src proto.Message) { + xxx_messageInfo_MerklePathChunk.Merge(m, src) +} +func (m *MerklePathChunk) XXX_Size() int { + return m.Size() +} +func (m *MerklePathChunk) XXX_DiscardUnknown() { + xxx_messageInfo_MerklePathChunk.DiscardUnknown(m) +} + +var xxx_messageInfo_MerklePathChunk proto.InternalMessageInfo + +func (m *MerklePathChunk) GetSibling_1() []byte { + if m != nil { + return m.Sibling_1 + } + return nil +} + +func (m *MerklePathChunk) GetSibling_2() []byte { + if m != nil { + return m.Sibling_2 + } + return nil +} + +func (m *MerklePathChunk) GetSibling_3() []byte { + if m != nil { + return m.Sibling_3 + } + return nil +} + +func init() { + proto.RegisterType((*StateCommitment)(nil), "penumbra.crypto.tct.v1alpha1.StateCommitment") + proto.RegisterType((*MerkleRoot)(nil), "penumbra.crypto.tct.v1alpha1.MerkleRoot") + proto.RegisterType((*StateCommitmentProof)(nil), "penumbra.crypto.tct.v1alpha1.StateCommitmentProof") + proto.RegisterType((*MerklePathChunk)(nil), "penumbra.crypto.tct.v1alpha1.MerklePathChunk") +} + +func init() { + proto.RegisterFile("penumbra/crypto/tct/v1alpha1/tct.proto", fileDescriptor_7a94190b2b9c1621) +} + +var fileDescriptor_7a94190b2b9c1621 = []byte{ + // 421 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x41, 0x8b, 0xd3, 0x40, + 0x14, 0xc7, 0x3b, 0xa9, 0x4a, 0x77, 0x14, 0x0b, 0x61, 0x0f, 0x45, 0x97, 0x58, 0x7a, 0xd0, 0x5e, + 0x4c, 0x68, 0x7b, 0x8b, 0xb7, 0xf6, 0x20, 0x08, 0x0b, 0x21, 0x86, 0x3d, 0x48, 0xa0, 0x4c, 0xc6, + 0x71, 0x67, 0xd8, 0x64, 0x5e, 0x98, 0xbc, 0x2c, 0xec, 0xb7, 0xf0, 0x33, 0x78, 0x14, 0xfc, 0x1e, + 0xe2, 0x69, 0x4f, 0xe2, 0x51, 0xd2, 0x9b, 0x9f, 0x42, 0xd2, 0x34, 0xdd, 0x5a, 0x30, 0x7b, 0x9b, + 0x37, 0xbf, 0xdf, 0xbc, 0xf9, 0xcf, 0xf0, 0xe8, 0xcb, 0x5c, 0xe8, 0x32, 0x4b, 0x0c, 0xf3, 0xb8, + 0xb9, 0xc9, 0x11, 0x3c, 0xe4, 0xe8, 0x5d, 0xcf, 0x58, 0x9a, 0x4b, 0x36, 0xab, 0x0b, 0x37, 0x37, + 0x80, 0x60, 0x9f, 0xb5, 0x9e, 0xdb, 0x78, 0x6e, 0x8d, 0x5a, 0x6f, 0xf2, 0x8a, 0x0e, 0xdf, 0x23, + 0x43, 0xb1, 0x82, 0x2c, 0x53, 0x98, 0x09, 0x8d, 0xf6, 0x29, 0x7d, 0xa8, 0xb4, 0x16, 0x66, 0x44, + 0xc6, 0x64, 0xfa, 0x24, 0x6c, 0x8a, 0xc9, 0x84, 0xd2, 0x73, 0x61, 0xae, 0x52, 0x11, 0x02, 0xfc, + 0xcf, 0xf9, 0x49, 0xe8, 0xe9, 0x51, 0xb7, 0xc0, 0x00, 0x7c, 0xb2, 0x2f, 0xe8, 0x50, 0x03, 0x8a, + 0x35, 0xdf, 0xef, 0x6f, 0x0f, 0x3e, 0x9e, 0xbf, 0x76, 0xbb, 0xd2, 0xb9, 0x47, 0xcd, 0xc2, 0xa7, + 0x75, 0x97, 0x83, 0xa8, 0xcf, 0xe8, 0x20, 0x87, 0x42, 0xa1, 0x02, 0x3d, 0xb2, 0xc6, 0x64, 0xfa, + 0x20, 0xdc, 0xd7, 0xf6, 0x3b, 0x7a, 0xc2, 0x4a, 0x94, 0xeb, 0x9c, 0xa1, 0x1c, 0xf5, 0xc7, 0xfd, + 0xfb, 0x6f, 0x6b, 0xde, 0x17, 0x30, 0x94, 0x2b, 0x59, 0xea, 0xab, 0x70, 0x50, 0x9f, 0xaf, 0xcb, + 0x89, 0xa4, 0xc3, 0x23, 0x68, 0x3f, 0xa7, 0x27, 0x85, 0x4a, 0x52, 0xa5, 0x2f, 0xd7, 0xb3, 0xdd, + 0x2f, 0x0c, 0x76, 0x1b, 0xb3, 0x43, 0x38, 0xdf, 0x06, 0xbb, 0x83, 0xf3, 0x43, 0xb8, 0x18, 0xf5, + 0xff, 0x81, 0x8b, 0xe5, 0x37, 0xeb, 0x7b, 0xe5, 0x90, 0xdb, 0xca, 0x21, 0xbf, 0x2b, 0x87, 0x7c, + 0xde, 0x38, 0xbd, 0xdb, 0x8d, 0xd3, 0xfb, 0xb5, 0x71, 0x7a, 0x74, 0xcc, 0x21, 0xeb, 0x7c, 0xc0, + 0x72, 0x10, 0xf1, 0xfa, 0xc3, 0x11, 0x02, 0xf2, 0x21, 0xba, 0x54, 0x28, 0xcb, 0xc4, 0xe5, 0x90, + 0x79, 0x1c, 0x8a, 0x0c, 0x0a, 0xcf, 0x88, 0x94, 0xdd, 0x08, 0xe3, 0x5d, 0xcf, 0xf7, 0x4b, 0x2e, + 0x99, 0xd2, 0x85, 0xd7, 0x35, 0x4a, 0x6f, 0x90, 0x63, 0xbb, 0xfe, 0x62, 0xf5, 0x83, 0x55, 0xf4, + 0xd5, 0x3a, 0x0b, 0xda, 0x18, 0xab, 0x26, 0x46, 0xc4, 0xd1, 0xbd, 0xd8, 0x49, 0x3f, 0xee, 0x70, + 0xdc, 0xe0, 0x38, 0xe2, 0x18, 0xb7, 0xb8, 0xb2, 0xa6, 0x5d, 0x38, 0x7e, 0x1b, 0x2c, 0xcf, 0x05, + 0xb2, 0x8f, 0x0c, 0xd9, 0x1f, 0xeb, 0x45, 0xab, 0xfa, 0x7e, 0xe3, 0xfa, 0x7e, 0xc4, 0xd1, 0xf7, + 0x5b, 0x3b, 0x79, 0xb4, 0x1d, 0xf2, 0xc5, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x14, 0x6c, 0x76, + 0x9e, 0x0e, 0x03, 0x00, 0x00, +} + +func (m *StateCommitment) 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 *StateCommitment) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StateCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintTct(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MerkleRoot) 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 *MerkleRoot) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MerkleRoot) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintTct(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StateCommitmentProof) 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 *StateCommitmentProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StateCommitmentProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AuthPath) > 0 { + for iNdEx := len(m.AuthPath) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AuthPath[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if m.Position != 0 { + i = encodeVarintTct(dAtA, i, uint64(m.Position)) + i-- + dAtA[i] = 0x10 + } + if m.NoteCommitment != nil { + { + size, err := m.NoteCommitment.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTct(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MerklePathChunk) 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 *MerklePathChunk) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MerklePathChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Sibling_3) > 0 { + i -= len(m.Sibling_3) + copy(dAtA[i:], m.Sibling_3) + i = encodeVarintTct(dAtA, i, uint64(len(m.Sibling_3))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sibling_2) > 0 { + i -= len(m.Sibling_2) + copy(dAtA[i:], m.Sibling_2) + i = encodeVarintTct(dAtA, i, uint64(len(m.Sibling_2))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sibling_1) > 0 { + i -= len(m.Sibling_1) + copy(dAtA[i:], m.Sibling_1) + i = encodeVarintTct(dAtA, i, uint64(len(m.Sibling_1))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintTct(dAtA []byte, offset int, v uint64) int { + offset -= sovTct(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *StateCommitment) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovTct(uint64(l)) + } + return n +} + +func (m *MerkleRoot) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovTct(uint64(l)) + } + return n +} + +func (m *StateCommitmentProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NoteCommitment != nil { + l = m.NoteCommitment.Size() + n += 1 + l + sovTct(uint64(l)) + } + if m.Position != 0 { + n += 1 + sovTct(uint64(m.Position)) + } + if len(m.AuthPath) > 0 { + for _, e := range m.AuthPath { + l = e.Size() + n += 1 + l + sovTct(uint64(l)) + } + } + return n +} + +func (m *MerklePathChunk) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sibling_1) + if l > 0 { + n += 1 + l + sovTct(uint64(l)) + } + l = len(m.Sibling_2) + if l > 0 { + n += 1 + l + sovTct(uint64(l)) + } + l = len(m.Sibling_3) + if l > 0 { + n += 1 + l + sovTct(uint64(l)) + } + return n +} + +func sovTct(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTct(x uint64) (n int) { + return sovTct(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *StateCommitment) 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 ErrIntOverflowTct + } + 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: StateCommitment: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StateCommitment: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTct + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MerkleRoot) 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 ErrIntOverflowTct + } + 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: MerkleRoot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MerkleRoot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTct + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StateCommitmentProof) 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 ErrIntOverflowTct + } + 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: StateCommitmentProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StateCommitmentProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NoteCommitment", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NoteCommitment == nil { + m.NoteCommitment = &StateCommitment{} + } + if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) + } + m.Position = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Position |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthPath", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTct + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AuthPath = append(m.AuthPath, &MerklePathChunk{}) + if err := m.AuthPath[len(m.AuthPath)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MerklePathChunk) 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 ErrIntOverflowTct + } + 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: MerklePathChunk: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MerklePathChunk: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sibling_1", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTct + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sibling_1 = append(m.Sibling_1[:0], dAtA[iNdEx:postIndex]...) + if m.Sibling_1 == nil { + m.Sibling_1 = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sibling_2", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTct + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sibling_2 = append(m.Sibling_2[:0], dAtA[iNdEx:postIndex]...) + if m.Sibling_2 == nil { + m.Sibling_2 = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sibling_3", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTct + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTct + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTct + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sibling_3 = append(m.Sibling_3[:0], dAtA[iNdEx:postIndex]...) + if m.Sibling_3 == nil { + m.Sibling_3 = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTct(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTct + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTct(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, ErrIntOverflowTct + } + 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, ErrIntOverflowTct + } + 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, ErrIntOverflowTct + } + 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, ErrInvalidLengthTct + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTct + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTct + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTct = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTct = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTct = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/custody/threshold/v1alpha1/threshold.pb.go b/relayer/chains/penumbra/custody/threshold/v1alpha1/threshold.pb.go new file mode 100644 index 000000000..a655e100c --- /dev/null +++ b/relayer/chains/penumbra/custody/threshold/v1alpha1/threshold.pb.go @@ -0,0 +1,3392 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/custody/threshold/v1alpha1/threshold.proto + +package thresholdv1alpha1 + +import ( + fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_frost/v1alpha1" + 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 + +// A key one can use to verify signatures. +// +// This key can also serve as a unique identifier for users. +type VerificationKey struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *VerificationKey) Reset() { *m = VerificationKey{} } +func (m *VerificationKey) String() string { return proto.CompactTextString(m) } +func (*VerificationKey) ProtoMessage() {} +func (*VerificationKey) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{0} +} +func (m *VerificationKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *VerificationKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_VerificationKey.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 *VerificationKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerificationKey.Merge(m, src) +} +func (m *VerificationKey) XXX_Size() int { + return m.Size() +} +func (m *VerificationKey) XXX_DiscardUnknown() { + xxx_messageInfo_VerificationKey.DiscardUnknown(m) +} + +var xxx_messageInfo_VerificationKey proto.InternalMessageInfo + +func (m *VerificationKey) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// A signature proving that a message was created by the owner of a verification key. +type Signature struct { + Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (m *Signature) Reset() { *m = Signature{} } +func (m *Signature) String() string { return proto.CompactTextString(m) } +func (*Signature) ProtoMessage() {} +func (*Signature) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{1} +} +func (m *Signature) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Signature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Signature.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 *Signature) XXX_Merge(src proto.Message) { + xxx_messageInfo_Signature.Merge(m, src) +} +func (m *Signature) XXX_Size() int { + return m.Size() +} +func (m *Signature) XXX_DiscardUnknown() { + xxx_messageInfo_Signature.DiscardUnknown(m) +} + +var xxx_messageInfo_Signature proto.InternalMessageInfo + +func (m *Signature) GetInner() []byte { + if m != nil { + return m.Inner + } + return nil +} + +// The message the coordinator sends in round 1 of the signing protocol. +type CoordinatorRound1 struct { + // The plan that the coordinator would like the followers to sign. + Plan *v1alpha1.TransactionPlan `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan,omitempty"` +} + +func (m *CoordinatorRound1) Reset() { *m = CoordinatorRound1{} } +func (m *CoordinatorRound1) String() string { return proto.CompactTextString(m) } +func (*CoordinatorRound1) ProtoMessage() {} +func (*CoordinatorRound1) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{2} +} +func (m *CoordinatorRound1) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CoordinatorRound1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CoordinatorRound1.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 *CoordinatorRound1) XXX_Merge(src proto.Message) { + xxx_messageInfo_CoordinatorRound1.Merge(m, src) +} +func (m *CoordinatorRound1) XXX_Size() int { + return m.Size() +} +func (m *CoordinatorRound1) XXX_DiscardUnknown() { + xxx_messageInfo_CoordinatorRound1.DiscardUnknown(m) +} + +var xxx_messageInfo_CoordinatorRound1 proto.InternalMessageInfo + +func (m *CoordinatorRound1) GetPlan() *v1alpha1.TransactionPlan { + if m != nil { + return m.Plan + } + return nil +} + +// The message the coordinator sends in round 2 of the signing protocol. +type CoordinatorRound2 struct { + // The underlying signing packages being sent to the followers, for each signature. + SigningPackages []*CoordinatorRound2_PartialSigningPackage `protobuf:"bytes,1,rep,name=signing_packages,json=signingPackages,proto3" json:"signing_packages,omitempty"` +} + +func (m *CoordinatorRound2) Reset() { *m = CoordinatorRound2{} } +func (m *CoordinatorRound2) String() string { return proto.CompactTextString(m) } +func (*CoordinatorRound2) ProtoMessage() {} +func (*CoordinatorRound2) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{3} +} +func (m *CoordinatorRound2) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CoordinatorRound2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CoordinatorRound2.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 *CoordinatorRound2) XXX_Merge(src proto.Message) { + xxx_messageInfo_CoordinatorRound2.Merge(m, src) +} +func (m *CoordinatorRound2) XXX_Size() int { + return m.Size() +} +func (m *CoordinatorRound2) XXX_DiscardUnknown() { + xxx_messageInfo_CoordinatorRound2.DiscardUnknown(m) +} + +var xxx_messageInfo_CoordinatorRound2 proto.InternalMessageInfo + +func (m *CoordinatorRound2) GetSigningPackages() []*CoordinatorRound2_PartialSigningPackage { + if m != nil { + return m.SigningPackages + } + return nil +} + +// A commitment along with a FROST identifier. +type CoordinatorRound2_IdentifiedCommitments struct { + // The serialization of a FROST identifier. + Identifier []byte `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"` + // The commitments this person has produced for this round of signing. + Commitments *v1alpha11.SigningCommitments `protobuf:"bytes,2,opt,name=commitments,proto3" json:"commitments,omitempty"` +} + +func (m *CoordinatorRound2_IdentifiedCommitments) Reset() { + *m = CoordinatorRound2_IdentifiedCommitments{} +} +func (m *CoordinatorRound2_IdentifiedCommitments) String() string { return proto.CompactTextString(m) } +func (*CoordinatorRound2_IdentifiedCommitments) ProtoMessage() {} +func (*CoordinatorRound2_IdentifiedCommitments) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{3, 0} +} +func (m *CoordinatorRound2_IdentifiedCommitments) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CoordinatorRound2_IdentifiedCommitments) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CoordinatorRound2_IdentifiedCommitments.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 *CoordinatorRound2_IdentifiedCommitments) XXX_Merge(src proto.Message) { + xxx_messageInfo_CoordinatorRound2_IdentifiedCommitments.Merge(m, src) +} +func (m *CoordinatorRound2_IdentifiedCommitments) XXX_Size() int { + return m.Size() +} +func (m *CoordinatorRound2_IdentifiedCommitments) XXX_DiscardUnknown() { + xxx_messageInfo_CoordinatorRound2_IdentifiedCommitments.DiscardUnknown(m) +} + +var xxx_messageInfo_CoordinatorRound2_IdentifiedCommitments proto.InternalMessageInfo + +func (m *CoordinatorRound2_IdentifiedCommitments) GetIdentifier() []byte { + if m != nil { + return m.Identifier + } + return nil +} + +func (m *CoordinatorRound2_IdentifiedCommitments) GetCommitments() *v1alpha11.SigningCommitments { + if m != nil { + return m.Commitments + } + return nil +} + +// A FROST signing package without a message. +// +// We structure things this way because the message is derived from the transaction plan. +// FROST expects the signing package to include the identified commitments *and* +// the message, but we have no need to include the message. +type CoordinatorRound2_PartialSigningPackage struct { + AllCommitments []*CoordinatorRound2_IdentifiedCommitments `protobuf:"bytes,1,rep,name=all_commitments,json=allCommitments,proto3" json:"all_commitments,omitempty"` +} + +func (m *CoordinatorRound2_PartialSigningPackage) Reset() { + *m = CoordinatorRound2_PartialSigningPackage{} +} +func (m *CoordinatorRound2_PartialSigningPackage) String() string { return proto.CompactTextString(m) } +func (*CoordinatorRound2_PartialSigningPackage) ProtoMessage() {} +func (*CoordinatorRound2_PartialSigningPackage) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{3, 1} +} +func (m *CoordinatorRound2_PartialSigningPackage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CoordinatorRound2_PartialSigningPackage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CoordinatorRound2_PartialSigningPackage.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 *CoordinatorRound2_PartialSigningPackage) XXX_Merge(src proto.Message) { + xxx_messageInfo_CoordinatorRound2_PartialSigningPackage.Merge(m, src) +} +func (m *CoordinatorRound2_PartialSigningPackage) XXX_Size() int { + return m.Size() +} +func (m *CoordinatorRound2_PartialSigningPackage) XXX_DiscardUnknown() { + xxx_messageInfo_CoordinatorRound2_PartialSigningPackage.DiscardUnknown(m) +} + +var xxx_messageInfo_CoordinatorRound2_PartialSigningPackage proto.InternalMessageInfo + +func (m *CoordinatorRound2_PartialSigningPackage) GetAllCommitments() []*CoordinatorRound2_IdentifiedCommitments { + if m != nil { + return m.AllCommitments + } + return nil +} + +// The first message the followers send back to the coordinator when signing. +type FollowerRound1 struct { + Inner *FollowerRound1_Inner `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` + // The verification key identifying the sender. + Pk *VerificationKey `protobuf:"bytes,2,opt,name=pk,proto3" json:"pk,omitempty"` + // A signature over the proto-encoded bytes of inner. + Sig *Signature `protobuf:"bytes,3,opt,name=sig,proto3" json:"sig,omitempty"` +} + +func (m *FollowerRound1) Reset() { *m = FollowerRound1{} } +func (m *FollowerRound1) String() string { return proto.CompactTextString(m) } +func (*FollowerRound1) ProtoMessage() {} +func (*FollowerRound1) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{4} +} +func (m *FollowerRound1) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FollowerRound1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FollowerRound1.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 *FollowerRound1) XXX_Merge(src proto.Message) { + xxx_messageInfo_FollowerRound1.Merge(m, src) +} +func (m *FollowerRound1) XXX_Size() int { + return m.Size() +} +func (m *FollowerRound1) XXX_DiscardUnknown() { + xxx_messageInfo_FollowerRound1.DiscardUnknown(m) +} + +var xxx_messageInfo_FollowerRound1 proto.InternalMessageInfo + +func (m *FollowerRound1) GetInner() *FollowerRound1_Inner { + if m != nil { + return m.Inner + } + return nil +} + +func (m *FollowerRound1) GetPk() *VerificationKey { + if m != nil { + return m.Pk + } + return nil +} + +func (m *FollowerRound1) GetSig() *Signature { + if m != nil { + return m.Sig + } + return nil +} + +// The inner message that will be signed by the follower. +type FollowerRound1_Inner struct { + // One signing commitment pair for each signature requested by the plan, in order. + Commitments []*v1alpha11.SigningCommitments `protobuf:"bytes,1,rep,name=commitments,proto3" json:"commitments,omitempty"` +} + +func (m *FollowerRound1_Inner) Reset() { *m = FollowerRound1_Inner{} } +func (m *FollowerRound1_Inner) String() string { return proto.CompactTextString(m) } +func (*FollowerRound1_Inner) ProtoMessage() {} +func (*FollowerRound1_Inner) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{4, 0} +} +func (m *FollowerRound1_Inner) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FollowerRound1_Inner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FollowerRound1_Inner.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 *FollowerRound1_Inner) XXX_Merge(src proto.Message) { + xxx_messageInfo_FollowerRound1_Inner.Merge(m, src) +} +func (m *FollowerRound1_Inner) XXX_Size() int { + return m.Size() +} +func (m *FollowerRound1_Inner) XXX_DiscardUnknown() { + xxx_messageInfo_FollowerRound1_Inner.DiscardUnknown(m) +} + +var xxx_messageInfo_FollowerRound1_Inner proto.InternalMessageInfo + +func (m *FollowerRound1_Inner) GetCommitments() []*v1alpha11.SigningCommitments { + if m != nil { + return m.Commitments + } + return nil +} + +// The second message the followers send back to the coordinator when signing. +type FollowerRound2 struct { + Inner *FollowerRound2_Inner `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` + // The verification key identifying the sender. + Pk *VerificationKey `protobuf:"bytes,2,opt,name=pk,proto3" json:"pk,omitempty"` + // A signature over the proto-encoded bytes of inner. + Sig *Signature `protobuf:"bytes,3,opt,name=sig,proto3" json:"sig,omitempty"` +} + +func (m *FollowerRound2) Reset() { *m = FollowerRound2{} } +func (m *FollowerRound2) String() string { return proto.CompactTextString(m) } +func (*FollowerRound2) ProtoMessage() {} +func (*FollowerRound2) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{5} +} +func (m *FollowerRound2) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FollowerRound2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FollowerRound2.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 *FollowerRound2) XXX_Merge(src proto.Message) { + xxx_messageInfo_FollowerRound2.Merge(m, src) +} +func (m *FollowerRound2) XXX_Size() int { + return m.Size() +} +func (m *FollowerRound2) XXX_DiscardUnknown() { + xxx_messageInfo_FollowerRound2.DiscardUnknown(m) +} + +var xxx_messageInfo_FollowerRound2 proto.InternalMessageInfo + +func (m *FollowerRound2) GetInner() *FollowerRound2_Inner { + if m != nil { + return m.Inner + } + return nil +} + +func (m *FollowerRound2) GetPk() *VerificationKey { + if m != nil { + return m.Pk + } + return nil +} + +func (m *FollowerRound2) GetSig() *Signature { + if m != nil { + return m.Sig + } + return nil +} + +// The inner message that will be signed by the follower. +type FollowerRound2_Inner struct { + // One share for each signature requested by the plan, in order. + Shares []*v1alpha11.SignatureShare `protobuf:"bytes,1,rep,name=shares,proto3" json:"shares,omitempty"` +} + +func (m *FollowerRound2_Inner) Reset() { *m = FollowerRound2_Inner{} } +func (m *FollowerRound2_Inner) String() string { return proto.CompactTextString(m) } +func (*FollowerRound2_Inner) ProtoMessage() {} +func (*FollowerRound2_Inner) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{5, 0} +} +func (m *FollowerRound2_Inner) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FollowerRound2_Inner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FollowerRound2_Inner.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 *FollowerRound2_Inner) XXX_Merge(src proto.Message) { + xxx_messageInfo_FollowerRound2_Inner.Merge(m, src) +} +func (m *FollowerRound2_Inner) XXX_Size() int { + return m.Size() +} +func (m *FollowerRound2_Inner) XXX_DiscardUnknown() { + xxx_messageInfo_FollowerRound2_Inner.DiscardUnknown(m) +} + +var xxx_messageInfo_FollowerRound2_Inner proto.InternalMessageInfo + +func (m *FollowerRound2_Inner) GetShares() []*v1alpha11.SignatureShare { + if m != nil { + return m.Shares + } + return nil +} + +// The first message we broadcast in the DKG protocol. +type DKGRound1 struct { + // The package we're sending to other people + Pkg *v1alpha11.DKGRound1Package `protobuf:"bytes,1,opt,name=pkg,proto3" json:"pkg,omitempty"` + // A commitment to a share of the nullifier-deriving key + NullifierCommitment []byte `protobuf:"bytes,2,opt,name=nullifier_commitment,json=nullifierCommitment,proto3" json:"nullifier_commitment,omitempty"` + // An encryption key for the second round. + Epk []byte `protobuf:"bytes,3,opt,name=epk,proto3" json:"epk,omitempty"` + // A verification key establishing an identity for the sender of this message. + Vk []byte `protobuf:"bytes,4,opt,name=vk,proto3" json:"vk,omitempty"` +} + +func (m *DKGRound1) Reset() { *m = DKGRound1{} } +func (m *DKGRound1) String() string { return proto.CompactTextString(m) } +func (*DKGRound1) ProtoMessage() {} +func (*DKGRound1) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{6} +} +func (m *DKGRound1) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DKGRound1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DKGRound1.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 *DKGRound1) XXX_Merge(src proto.Message) { + xxx_messageInfo_DKGRound1.Merge(m, src) +} +func (m *DKGRound1) XXX_Size() int { + return m.Size() +} +func (m *DKGRound1) XXX_DiscardUnknown() { + xxx_messageInfo_DKGRound1.DiscardUnknown(m) +} + +var xxx_messageInfo_DKGRound1 proto.InternalMessageInfo + +func (m *DKGRound1) GetPkg() *v1alpha11.DKGRound1Package { + if m != nil { + return m.Pkg + } + return nil +} + +func (m *DKGRound1) GetNullifierCommitment() []byte { + if m != nil { + return m.NullifierCommitment + } + return nil +} + +func (m *DKGRound1) GetEpk() []byte { + if m != nil { + return m.Epk + } + return nil +} + +func (m *DKGRound1) GetVk() []byte { + if m != nil { + return m.Vk + } + return nil +} + +// The second message we broadcast in the DKG protocol. +type DKGRound2 struct { + Inner *DKGRound2_Inner `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` + // The verification key identifying the sender. + Vk []byte `protobuf:"bytes,2,opt,name=vk,proto3" json:"vk,omitempty"` + // A signature over the proto-encoded inner message. + Sig []byte `protobuf:"bytes,3,opt,name=sig,proto3" json:"sig,omitempty"` +} + +func (m *DKGRound2) Reset() { *m = DKGRound2{} } +func (m *DKGRound2) String() string { return proto.CompactTextString(m) } +func (*DKGRound2) ProtoMessage() {} +func (*DKGRound2) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{7} +} +func (m *DKGRound2) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DKGRound2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DKGRound2.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 *DKGRound2) XXX_Merge(src proto.Message) { + xxx_messageInfo_DKGRound2.Merge(m, src) +} +func (m *DKGRound2) XXX_Size() int { + return m.Size() +} +func (m *DKGRound2) XXX_DiscardUnknown() { + xxx_messageInfo_DKGRound2.DiscardUnknown(m) +} + +var xxx_messageInfo_DKGRound2 proto.InternalMessageInfo + +func (m *DKGRound2) GetInner() *DKGRound2_Inner { + if m != nil { + return m.Inner + } + return nil +} + +func (m *DKGRound2) GetVk() []byte { + if m != nil { + return m.Vk + } + return nil +} + +func (m *DKGRound2) GetSig() []byte { + if m != nil { + return m.Sig + } + return nil +} + +// A round2 package, encrypted, along with an identifier for the recipient. +type DKGRound2_TargetedPackage struct { + // A verification key identifying the recipient. + Vk []byte `protobuf:"bytes,1,opt,name=vk,proto3" json:"vk,omitempty"` + // The ciphertext of an encrypted frost package for round 2. + EncryptedPackage []byte `protobuf:"bytes,2,opt,name=encrypted_package,json=encryptedPackage,proto3" json:"encrypted_package,omitempty"` +} + +func (m *DKGRound2_TargetedPackage) Reset() { *m = DKGRound2_TargetedPackage{} } +func (m *DKGRound2_TargetedPackage) String() string { return proto.CompactTextString(m) } +func (*DKGRound2_TargetedPackage) ProtoMessage() {} +func (*DKGRound2_TargetedPackage) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{7, 0} +} +func (m *DKGRound2_TargetedPackage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DKGRound2_TargetedPackage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DKGRound2_TargetedPackage.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 *DKGRound2_TargetedPackage) XXX_Merge(src proto.Message) { + xxx_messageInfo_DKGRound2_TargetedPackage.Merge(m, src) +} +func (m *DKGRound2_TargetedPackage) XXX_Size() int { + return m.Size() +} +func (m *DKGRound2_TargetedPackage) XXX_DiscardUnknown() { + xxx_messageInfo_DKGRound2_TargetedPackage.DiscardUnknown(m) +} + +var xxx_messageInfo_DKGRound2_TargetedPackage proto.InternalMessageInfo + +func (m *DKGRound2_TargetedPackage) GetVk() []byte { + if m != nil { + return m.Vk + } + return nil +} + +func (m *DKGRound2_TargetedPackage) GetEncryptedPackage() []byte { + if m != nil { + return m.EncryptedPackage + } + return nil +} + +// An inner message that will be signed. +type DKGRound2_Inner struct { + // Encrypted packages for each recipient. + EncryptedPackages []*DKGRound2_TargetedPackage `protobuf:"bytes,1,rep,name=encrypted_packages,json=encryptedPackages,proto3" json:"encrypted_packages,omitempty"` + // An opening of the share of the nullifier-deriving key commitment + Nullifier []byte `protobuf:"bytes,2,opt,name=nullifier,proto3" json:"nullifier,omitempty"` +} + +func (m *DKGRound2_Inner) Reset() { *m = DKGRound2_Inner{} } +func (m *DKGRound2_Inner) String() string { return proto.CompactTextString(m) } +func (*DKGRound2_Inner) ProtoMessage() {} +func (*DKGRound2_Inner) Descriptor() ([]byte, []int) { + return fileDescriptor_a211a6df1a59c634, []int{7, 1} +} +func (m *DKGRound2_Inner) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DKGRound2_Inner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DKGRound2_Inner.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 *DKGRound2_Inner) XXX_Merge(src proto.Message) { + xxx_messageInfo_DKGRound2_Inner.Merge(m, src) +} +func (m *DKGRound2_Inner) XXX_Size() int { + return m.Size() +} +func (m *DKGRound2_Inner) XXX_DiscardUnknown() { + xxx_messageInfo_DKGRound2_Inner.DiscardUnknown(m) +} + +var xxx_messageInfo_DKGRound2_Inner proto.InternalMessageInfo + +func (m *DKGRound2_Inner) GetEncryptedPackages() []*DKGRound2_TargetedPackage { + if m != nil { + return m.EncryptedPackages + } + return nil +} + +func (m *DKGRound2_Inner) GetNullifier() []byte { + if m != nil { + return m.Nullifier + } + return nil +} + +func init() { + proto.RegisterType((*VerificationKey)(nil), "penumbra.custody.threshold.v1alpha1.VerificationKey") + proto.RegisterType((*Signature)(nil), "penumbra.custody.threshold.v1alpha1.Signature") + proto.RegisterType((*CoordinatorRound1)(nil), "penumbra.custody.threshold.v1alpha1.CoordinatorRound1") + proto.RegisterType((*CoordinatorRound2)(nil), "penumbra.custody.threshold.v1alpha1.CoordinatorRound2") + proto.RegisterType((*CoordinatorRound2_IdentifiedCommitments)(nil), "penumbra.custody.threshold.v1alpha1.CoordinatorRound2.IdentifiedCommitments") + proto.RegisterType((*CoordinatorRound2_PartialSigningPackage)(nil), "penumbra.custody.threshold.v1alpha1.CoordinatorRound2.PartialSigningPackage") + proto.RegisterType((*FollowerRound1)(nil), "penumbra.custody.threshold.v1alpha1.FollowerRound1") + proto.RegisterType((*FollowerRound1_Inner)(nil), "penumbra.custody.threshold.v1alpha1.FollowerRound1.Inner") + proto.RegisterType((*FollowerRound2)(nil), "penumbra.custody.threshold.v1alpha1.FollowerRound2") + proto.RegisterType((*FollowerRound2_Inner)(nil), "penumbra.custody.threshold.v1alpha1.FollowerRound2.Inner") + proto.RegisterType((*DKGRound1)(nil), "penumbra.custody.threshold.v1alpha1.DKGRound1") + proto.RegisterType((*DKGRound2)(nil), "penumbra.custody.threshold.v1alpha1.DKGRound2") + proto.RegisterType((*DKGRound2_TargetedPackage)(nil), "penumbra.custody.threshold.v1alpha1.DKGRound2.TargetedPackage") + proto.RegisterType((*DKGRound2_Inner)(nil), "penumbra.custody.threshold.v1alpha1.DKGRound2.Inner") +} + +func init() { + proto.RegisterFile("penumbra/custody/threshold/v1alpha1/threshold.proto", fileDescriptor_a211a6df1a59c634) +} + +var fileDescriptor_a211a6df1a59c634 = []byte{ + // 816 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x5f, 0x6b, 0xc3, 0x54, + 0x1c, 0x5d, 0xd2, 0x6d, 0xb0, 0xdb, 0xd2, 0x6e, 0x71, 0x83, 0x52, 0xa4, 0xcc, 0x0e, 0xdc, 0x40, + 0x48, 0x68, 0x3a, 0x18, 0x76, 0x22, 0xb2, 0x0e, 0xc7, 0x9c, 0xba, 0x90, 0x95, 0x21, 0x52, 0x19, + 0x77, 0xc9, 0x6d, 0x7a, 0x69, 0x72, 0x6f, 0xb8, 0xb9, 0xed, 0xe8, 0x97, 0x10, 0x1f, 0xc4, 0x0f, + 0xe0, 0xa3, 0xe0, 0xab, 0x5f, 0xc0, 0x17, 0xf1, 0x69, 0xbe, 0xf9, 0x38, 0xda, 0x37, 0x3f, 0x85, + 0xe4, 0xcf, 0x4d, 0xd2, 0x6e, 0x4a, 0x86, 0x7b, 0xf0, 0xad, 0xf9, 0xe5, 0x77, 0xce, 0xef, 0xdc, + 0x73, 0xee, 0xbd, 0x0d, 0xe8, 0xf8, 0x88, 0x4c, 0xbc, 0x7b, 0x06, 0x35, 0x6b, 0x12, 0x70, 0x6a, + 0xcf, 0x34, 0x3e, 0x62, 0x28, 0x18, 0x51, 0xd7, 0xd6, 0xa6, 0x6d, 0xe8, 0xfa, 0x23, 0xd8, 0xce, + 0x4a, 0xaa, 0xcf, 0x28, 0xa7, 0xca, 0x81, 0x00, 0xa9, 0x09, 0x48, 0xcd, 0x3a, 0x04, 0xa8, 0x71, + 0x9c, 0x31, 0x53, 0x86, 0x34, 0xce, 0x20, 0x09, 0xa0, 0xc5, 0x31, 0x25, 0x39, 0xe2, 0xac, 0x18, + 0x53, 0x37, 0x3e, 0xca, 0x50, 0x6c, 0xe6, 0x73, 0xaa, 0xd9, 0xc8, 0x82, 0xc3, 0xce, 0xc9, 0xc9, + 0xdd, 0x90, 0xd1, 0x80, 0x67, 0xd0, 0xe5, 0x7a, 0x8c, 0x6e, 0x1d, 0x82, 0xda, 0x2d, 0x62, 0x78, + 0x88, 0x2d, 0x18, 0x72, 0x5e, 0xa1, 0x99, 0xb2, 0x0b, 0x36, 0x30, 0x21, 0x88, 0xd5, 0xa5, 0x7d, + 0xe9, 0xa8, 0x62, 0xc6, 0x0f, 0xad, 0xf7, 0xc0, 0xd6, 0x0d, 0x76, 0x08, 0xe4, 0x13, 0x86, 0xfe, + 0xa1, 0x65, 0x00, 0x76, 0x7a, 0x94, 0x32, 0x1b, 0x13, 0xc8, 0x29, 0x33, 0xe9, 0x84, 0xd8, 0x6d, + 0xe5, 0x02, 0xac, 0xfb, 0x2e, 0x24, 0x51, 0x67, 0x59, 0xef, 0xa8, 0x99, 0x11, 0x94, 0x21, 0x35, + 0xbf, 0x1c, 0x21, 0x54, 0xed, 0x67, 0x45, 0xc3, 0x85, 0xc4, 0x8c, 0x08, 0x5a, 0xbf, 0x94, 0x9e, + 0xd3, 0xeb, 0xca, 0x03, 0xd8, 0x0e, 0xb0, 0x43, 0x30, 0x71, 0xee, 0x7c, 0x68, 0x8d, 0xa1, 0x83, + 0x82, 0xba, 0xb4, 0x5f, 0x3a, 0x2a, 0xeb, 0x9f, 0xab, 0x05, 0x3c, 0x57, 0x9f, 0x31, 0xaa, 0x06, + 0x64, 0x1c, 0x43, 0xf7, 0x26, 0x66, 0x35, 0x62, 0x52, 0xb3, 0x16, 0x2c, 0x3d, 0x07, 0x8d, 0x1f, + 0x24, 0xb0, 0x77, 0x69, 0x23, 0xc2, 0xf1, 0x10, 0x23, 0xbb, 0x47, 0x3d, 0x0f, 0x73, 0x0f, 0x11, + 0x1e, 0x28, 0x4d, 0x00, 0xb0, 0x78, 0x21, 0x1c, 0xca, 0x55, 0x94, 0x6f, 0x40, 0xd9, 0xca, 0xda, + 0xeb, 0x72, 0x64, 0xcc, 0x69, 0x4e, 0x6d, 0x14, 0xa3, 0xba, 0x12, 0x57, 0xaa, 0x38, 0x11, 0x96, + 0x9b, 0x68, 0xe6, 0xf9, 0x1a, 0xdf, 0x4a, 0x60, 0xef, 0xc5, 0x35, 0x28, 0x13, 0x50, 0x83, 0xae, + 0x7b, 0x97, 0x1f, 0xfe, 0xdf, 0xac, 0x7a, 0x71, 0xfd, 0x66, 0x15, 0xba, 0x6e, 0xee, 0xb9, 0xf5, + 0x87, 0x0c, 0xaa, 0x9f, 0x52, 0xd7, 0xa5, 0x0f, 0x48, 0x6c, 0x8a, 0xeb, 0xfc, 0xfe, 0x29, 0xeb, + 0x1f, 0x16, 0x9a, 0xbf, 0xcc, 0xa1, 0x5e, 0x86, 0x04, 0xc9, 0xd6, 0x53, 0xce, 0x81, 0xec, 0x8f, + 0x13, 0x2b, 0x8f, 0x0b, 0xb1, 0xad, 0xec, 0x7a, 0x53, 0xf6, 0xc7, 0xca, 0x27, 0xa0, 0x14, 0x60, + 0xa7, 0x5e, 0x8a, 0x68, 0xd4, 0x42, 0x34, 0xe9, 0x99, 0x30, 0x43, 0x68, 0x63, 0x08, 0x36, 0x22, + 0x5d, 0xab, 0x21, 0xc7, 0x3e, 0xbf, 0x59, 0xc8, 0xad, 0x5f, 0x57, 0x3d, 0xd5, 0xdf, 0xc0, 0x53, + 0xfd, 0xff, 0xe9, 0xe9, 0x57, 0xc2, 0xd3, 0x6b, 0xb0, 0x19, 0x8c, 0x20, 0x4b, 0x4f, 0xf8, 0xc9, + 0xab, 0xec, 0x8c, 0x18, 0x6f, 0x42, 0xbc, 0x99, 0xd0, 0xb4, 0x7e, 0x96, 0xc0, 0xd6, 0xf9, 0xd5, + 0x45, 0xb2, 0x29, 0xaf, 0x40, 0xc9, 0x1f, 0x3b, 0x2f, 0xd8, 0xf7, 0xef, 0xdc, 0x29, 0x81, 0xb8, + 0x2a, 0x42, 0x16, 0xa5, 0x0d, 0x76, 0xc9, 0xc4, 0x75, 0xa3, 0x13, 0x9f, 0x3b, 0x71, 0x91, 0x9d, + 0x15, 0xf3, 0x9d, 0xf4, 0x5d, 0x96, 0xb0, 0xb2, 0x0d, 0x4a, 0xc8, 0x1f, 0x47, 0x4e, 0x55, 0xcc, + 0xf0, 0xa7, 0x52, 0x05, 0xf2, 0x74, 0x5c, 0x5f, 0x8f, 0x0a, 0xf2, 0x74, 0xdc, 0x7a, 0x92, 0x33, + 0xbd, 0xba, 0xf2, 0xd9, 0x72, 0xe0, 0xc5, 0x22, 0x4a, 0xe1, 0xcb, 0x59, 0xc7, 0x93, 0x64, 0x31, + 0x29, 0xd4, 0x22, 0x52, 0xab, 0xc4, 0x29, 0x7c, 0x09, 0x6a, 0x7d, 0xc8, 0x1c, 0xc4, 0x91, 0x2d, + 0xee, 0x93, 0x18, 0x24, 0xa5, 0xa0, 0x0f, 0xc0, 0x0e, 0x22, 0x91, 0x5b, 0xc8, 0x16, 0xb7, 0x71, + 0xc2, 0xb9, 0x9d, 0xbe, 0x48, 0xc0, 0x8d, 0xef, 0x25, 0x11, 0xab, 0x07, 0x94, 0x67, 0x30, 0x11, + 0xf1, 0xc7, 0xaf, 0x5c, 0xd4, 0x8a, 0x44, 0x73, 0x67, 0x75, 0x6e, 0xa0, 0xbc, 0x0b, 0xb6, 0x52, + 0xf7, 0x13, 0x75, 0x59, 0xe1, 0x6c, 0x21, 0xff, 0x36, 0x6f, 0x4a, 0x8f, 0xf3, 0xa6, 0xf4, 0x34, + 0x6f, 0x4a, 0xdf, 0x2d, 0x9a, 0x6b, 0x8f, 0x8b, 0xe6, 0xda, 0x9f, 0x8b, 0xe6, 0x1a, 0x38, 0xb4, + 0xa8, 0x57, 0x44, 0xce, 0x59, 0xb5, 0x2f, 0x6a, 0x46, 0xf8, 0x1f, 0x6b, 0x48, 0x5f, 0x43, 0x07, + 0xf3, 0xd1, 0xe4, 0x5e, 0xb5, 0xa8, 0xa7, 0x59, 0x34, 0xf0, 0x68, 0xa0, 0x31, 0xe4, 0xc2, 0x19, + 0x62, 0xda, 0x54, 0x4f, 0x7f, 0x5a, 0x23, 0x88, 0x49, 0xa0, 0x15, 0xf8, 0xbe, 0x38, 0x4d, 0x4b, + 0xa2, 0xf2, 0xa3, 0x5c, 0x32, 0x7a, 0xfd, 0x9f, 0xe4, 0x03, 0x43, 0x08, 0xec, 0x25, 0x02, 0x53, + 0x31, 0xea, 0x6d, 0xd2, 0xfb, 0x7b, 0xd6, 0x35, 0x48, 0xba, 0x06, 0x69, 0xd7, 0x40, 0x74, 0xcd, + 0x65, 0xad, 0x40, 0xd7, 0xe0, 0xc2, 0x38, 0xfb, 0x02, 0x71, 0x68, 0x43, 0x0e, 0xff, 0x92, 0xdf, + 0x17, 0x88, 0x6e, 0x37, 0x81, 0x74, 0xbb, 0x29, 0xa6, 0xdb, 0x15, 0xa0, 0xfb, 0xcd, 0xe8, 0xe3, + 0xa3, 0xf3, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbc, 0xfc, 0x97, 0xa4, 0x4c, 0x09, 0x00, 0x00, +} + +func (m *VerificationKey) 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 *VerificationKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerificationKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Signature) 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 *Signature) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Signature) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Inner) > 0 { + i -= len(m.Inner) + copy(dAtA[i:], m.Inner) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.Inner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CoordinatorRound1) 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 *CoordinatorRound1) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CoordinatorRound1) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Plan != nil { + { + size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CoordinatorRound2) 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 *CoordinatorRound2) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CoordinatorRound2) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.SigningPackages) > 0 { + for iNdEx := len(m.SigningPackages) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SigningPackages[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CoordinatorRound2_IdentifiedCommitments) 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 *CoordinatorRound2_IdentifiedCommitments) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CoordinatorRound2_IdentifiedCommitments) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Commitments != nil { + { + size, err := m.Commitments.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Identifier) > 0 { + i -= len(m.Identifier) + copy(dAtA[i:], m.Identifier) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.Identifier))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CoordinatorRound2_PartialSigningPackage) 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 *CoordinatorRound2_PartialSigningPackage) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CoordinatorRound2_PartialSigningPackage) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AllCommitments) > 0 { + for iNdEx := len(m.AllCommitments) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AllCommitments[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *FollowerRound1) 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 *FollowerRound1) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FollowerRound1) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Sig != nil { + { + size, err := m.Sig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Pk != nil { + { + size, err := m.Pk.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Inner != nil { + { + size, err := m.Inner.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *FollowerRound1_Inner) 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 *FollowerRound1_Inner) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FollowerRound1_Inner) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Commitments) > 0 { + for iNdEx := len(m.Commitments) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Commitments[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *FollowerRound2) 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 *FollowerRound2) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FollowerRound2) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Sig != nil { + { + size, err := m.Sig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Pk != nil { + { + size, err := m.Pk.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Inner != nil { + { + size, err := m.Inner.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *FollowerRound2_Inner) 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 *FollowerRound2_Inner) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FollowerRound2_Inner) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Shares) > 0 { + for iNdEx := len(m.Shares) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Shares[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *DKGRound1) 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 *DKGRound1) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DKGRound1) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Vk) > 0 { + i -= len(m.Vk) + copy(dAtA[i:], m.Vk) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.Vk))) + i-- + dAtA[i] = 0x22 + } + if len(m.Epk) > 0 { + i -= len(m.Epk) + copy(dAtA[i:], m.Epk) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.Epk))) + i-- + dAtA[i] = 0x1a + } + if len(m.NullifierCommitment) > 0 { + i -= len(m.NullifierCommitment) + copy(dAtA[i:], m.NullifierCommitment) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.NullifierCommitment))) + i-- + dAtA[i] = 0x12 + } + if m.Pkg != nil { + { + size, err := m.Pkg.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DKGRound2) 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 *DKGRound2) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DKGRound2) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Sig) > 0 { + i -= len(m.Sig) + copy(dAtA[i:], m.Sig) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.Sig))) + i-- + dAtA[i] = 0x1a + } + if len(m.Vk) > 0 { + i -= len(m.Vk) + copy(dAtA[i:], m.Vk) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.Vk))) + i-- + dAtA[i] = 0x12 + } + if m.Inner != nil { + { + size, err := m.Inner.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DKGRound2_TargetedPackage) 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 *DKGRound2_TargetedPackage) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DKGRound2_TargetedPackage) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.EncryptedPackage) > 0 { + i -= len(m.EncryptedPackage) + copy(dAtA[i:], m.EncryptedPackage) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.EncryptedPackage))) + i-- + dAtA[i] = 0x12 + } + if len(m.Vk) > 0 { + i -= len(m.Vk) + copy(dAtA[i:], m.Vk) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.Vk))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DKGRound2_Inner) 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 *DKGRound2_Inner) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DKGRound2_Inner) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Nullifier) > 0 { + i -= len(m.Nullifier) + copy(dAtA[i:], m.Nullifier) + i = encodeVarintThreshold(dAtA, i, uint64(len(m.Nullifier))) + i-- + dAtA[i] = 0x12 + } + if len(m.EncryptedPackages) > 0 { + for iNdEx := len(m.EncryptedPackages) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.EncryptedPackages[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintThreshold(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintThreshold(dAtA []byte, offset int, v uint64) int { + offset -= sovThreshold(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *VerificationKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func (m *Signature) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Inner) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func (m *CoordinatorRound1) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Plan != nil { + l = m.Plan.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func (m *CoordinatorRound2) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.SigningPackages) > 0 { + for _, e := range m.SigningPackages { + l = e.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + } + return n +} + +func (m *CoordinatorRound2_IdentifiedCommitments) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Identifier) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + if m.Commitments != nil { + l = m.Commitments.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func (m *CoordinatorRound2_PartialSigningPackage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.AllCommitments) > 0 { + for _, e := range m.AllCommitments { + l = e.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + } + return n +} + +func (m *FollowerRound1) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Inner != nil { + l = m.Inner.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + if m.Pk != nil { + l = m.Pk.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + if m.Sig != nil { + l = m.Sig.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func (m *FollowerRound1_Inner) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Commitments) > 0 { + for _, e := range m.Commitments { + l = e.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + } + return n +} + +func (m *FollowerRound2) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Inner != nil { + l = m.Inner.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + if m.Pk != nil { + l = m.Pk.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + if m.Sig != nil { + l = m.Sig.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func (m *FollowerRound2_Inner) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Shares) > 0 { + for _, e := range m.Shares { + l = e.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + } + return n +} + +func (m *DKGRound1) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pkg != nil { + l = m.Pkg.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + l = len(m.NullifierCommitment) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + l = len(m.Epk) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + l = len(m.Vk) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func (m *DKGRound2) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Inner != nil { + l = m.Inner.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + l = len(m.Vk) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + l = len(m.Sig) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func (m *DKGRound2_TargetedPackage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Vk) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + l = len(m.EncryptedPackage) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func (m *DKGRound2_Inner) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.EncryptedPackages) > 0 { + for _, e := range m.EncryptedPackages { + l = e.Size() + n += 1 + l + sovThreshold(uint64(l)) + } + } + l = len(m.Nullifier) + if l > 0 { + n += 1 + l + sovThreshold(uint64(l)) + } + return n +} + +func sovThreshold(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozThreshold(x uint64) (n int) { + return sovThreshold(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *VerificationKey) 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 ErrIntOverflowThreshold + } + 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: VerificationKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VerificationKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Signature) 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 ErrIntOverflowThreshold + } + 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: Signature: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Signature: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) + if m.Inner == nil { + m.Inner = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CoordinatorRound1) 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 ErrIntOverflowThreshold + } + 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: CoordinatorRound1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CoordinatorRound1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Plan == nil { + m.Plan = &v1alpha1.TransactionPlan{} + } + if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CoordinatorRound2) 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 ErrIntOverflowThreshold + } + 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: CoordinatorRound2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CoordinatorRound2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SigningPackages", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SigningPackages = append(m.SigningPackages, &CoordinatorRound2_PartialSigningPackage{}) + if err := m.SigningPackages[len(m.SigningPackages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CoordinatorRound2_IdentifiedCommitments) 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 ErrIntOverflowThreshold + } + 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: IdentifiedCommitments: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IdentifiedCommitments: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Identifier", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Identifier = append(m.Identifier[:0], dAtA[iNdEx:postIndex]...) + if m.Identifier == nil { + m.Identifier = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commitments", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Commitments == nil { + m.Commitments = &v1alpha11.SigningCommitments{} + } + if err := m.Commitments.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CoordinatorRound2_PartialSigningPackage) 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 ErrIntOverflowThreshold + } + 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: PartialSigningPackage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PartialSigningPackage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllCommitments", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AllCommitments = append(m.AllCommitments, &CoordinatorRound2_IdentifiedCommitments{}) + if err := m.AllCommitments[len(m.AllCommitments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FollowerRound1) 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 ErrIntOverflowThreshold + } + 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: FollowerRound1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FollowerRound1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Inner == nil { + m.Inner = &FollowerRound1_Inner{} + } + if err := m.Inner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pk", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pk == nil { + m.Pk = &VerificationKey{} + } + if err := m.Pk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Sig == nil { + m.Sig = &Signature{} + } + if err := m.Sig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FollowerRound1_Inner) 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 ErrIntOverflowThreshold + } + 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: Inner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Inner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commitments", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Commitments = append(m.Commitments, &v1alpha11.SigningCommitments{}) + if err := m.Commitments[len(m.Commitments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FollowerRound2) 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 ErrIntOverflowThreshold + } + 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: FollowerRound2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FollowerRound2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Inner == nil { + m.Inner = &FollowerRound2_Inner{} + } + if err := m.Inner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pk", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pk == nil { + m.Pk = &VerificationKey{} + } + if err := m.Pk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Sig == nil { + m.Sig = &Signature{} + } + if err := m.Sig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FollowerRound2_Inner) 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 ErrIntOverflowThreshold + } + 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: Inner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Inner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Shares", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Shares = append(m.Shares, &v1alpha11.SignatureShare{}) + if err := m.Shares[len(m.Shares)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DKGRound1) 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 ErrIntOverflowThreshold + } + 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: DKGRound1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DKGRound1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pkg", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pkg == nil { + m.Pkg = &v1alpha11.DKGRound1Package{} + } + if err := m.Pkg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NullifierCommitment", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NullifierCommitment = append(m.NullifierCommitment[:0], dAtA[iNdEx:postIndex]...) + if m.NullifierCommitment == nil { + m.NullifierCommitment = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epk", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Epk = append(m.Epk[:0], dAtA[iNdEx:postIndex]...) + if m.Epk == nil { + m.Epk = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vk", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Vk = append(m.Vk[:0], dAtA[iNdEx:postIndex]...) + if m.Vk == nil { + m.Vk = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DKGRound2) 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 ErrIntOverflowThreshold + } + 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: DKGRound2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DKGRound2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Inner == nil { + m.Inner = &DKGRound2_Inner{} + } + if err := m.Inner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vk", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Vk = append(m.Vk[:0], dAtA[iNdEx:postIndex]...) + if m.Vk == nil { + m.Vk = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sig", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sig = append(m.Sig[:0], dAtA[iNdEx:postIndex]...) + if m.Sig == nil { + m.Sig = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DKGRound2_TargetedPackage) 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 ErrIntOverflowThreshold + } + 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: TargetedPackage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TargetedPackage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vk", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Vk = append(m.Vk[:0], dAtA[iNdEx:postIndex]...) + if m.Vk == nil { + m.Vk = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EncryptedPackage", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EncryptedPackage = append(m.EncryptedPackage[:0], dAtA[iNdEx:postIndex]...) + if m.EncryptedPackage == nil { + m.EncryptedPackage = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DKGRound2_Inner) 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 ErrIntOverflowThreshold + } + 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: Inner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Inner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EncryptedPackages", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EncryptedPackages = append(m.EncryptedPackages, &DKGRound2_TargetedPackage{}) + if err := m.EncryptedPackages[len(m.EncryptedPackages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThreshold + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThreshold + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthThreshold + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Nullifier = append(m.Nullifier[:0], dAtA[iNdEx:postIndex]...) + if m.Nullifier == nil { + m.Nullifier = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThreshold(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthThreshold + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipThreshold(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, ErrIntOverflowThreshold + } + 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, ErrIntOverflowThreshold + } + 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, ErrIntOverflowThreshold + } + 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, ErrInvalidLengthThreshold + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupThreshold + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthThreshold + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthThreshold = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowThreshold = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupThreshold = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/custody/v1alpha1/custody.pb.go b/relayer/chains/penumbra/custody/v1alpha1/custody.pb.go index d30aa8c26..d53f55fa0 100644 --- a/relayer/chains/penumbra/custody/v1alpha1/custody.pb.go +++ b/relayer/chains/penumbra/custody/v1alpha1/custody.pb.go @@ -8,7 +8,7 @@ import ( fmt "fmt" grpc1 "github.com/cosmos/gogoproto/grpc" proto "github.com/cosmos/gogoproto/proto" - v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1" v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1alpha1" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" @@ -32,10 +32,10 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type AuthorizeRequest struct { // The transaction plan to authorize. Plan *v1alpha1.TransactionPlan `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan,omitempty"` - // Identifies the FVK (and hence the spend authorization key) to use for signing. - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,2,opt,name=account_group_id,json=accountGroupId,proto3" json:"account_group_id,omitempty"` // Optionally, pre-authorization data, if required by the custodian. // + // Pre-authorization data is backend-specific, and backends are free to ignore it. + // // Multiple `PreAuthorization` packets can be included in a single request, // to support multi-party pre-authorizations. PreAuthorizations []*PreAuthorization `protobuf:"bytes,3,rep,name=pre_authorizations,json=preAuthorizations,proto3" json:"pre_authorizations,omitempty"` @@ -81,13 +81,6 @@ func (m *AuthorizeRequest) GetPlan() *v1alpha1.TransactionPlan { return nil } -func (m *AuthorizeRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if m != nil { - return m.AccountGroupId - } - return nil -} - func (m *AuthorizeRequest) GetPreAuthorizations() []*PreAuthorization { if m != nil { return m.PreAuthorizations @@ -271,11 +264,184 @@ func (m *PreAuthorization_Ed25519) GetSig() []byte { return nil } +type ExportFullViewingKeyRequest struct { +} + +func (m *ExportFullViewingKeyRequest) Reset() { *m = ExportFullViewingKeyRequest{} } +func (m *ExportFullViewingKeyRequest) String() string { return proto.CompactTextString(m) } +func (*ExportFullViewingKeyRequest) ProtoMessage() {} +func (*ExportFullViewingKeyRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_8c8c99775232419d, []int{3} +} +func (m *ExportFullViewingKeyRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExportFullViewingKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExportFullViewingKeyRequest.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 *ExportFullViewingKeyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExportFullViewingKeyRequest.Merge(m, src) +} +func (m *ExportFullViewingKeyRequest) XXX_Size() int { + return m.Size() +} +func (m *ExportFullViewingKeyRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ExportFullViewingKeyRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ExportFullViewingKeyRequest proto.InternalMessageInfo + +type ExportFullViewingKeyResponse struct { + // The full viewing key. + FullViewingKey *v1alpha11.FullViewingKey `protobuf:"bytes,1,opt,name=full_viewing_key,json=fullViewingKey,proto3" json:"full_viewing_key,omitempty"` +} + +func (m *ExportFullViewingKeyResponse) Reset() { *m = ExportFullViewingKeyResponse{} } +func (m *ExportFullViewingKeyResponse) String() string { return proto.CompactTextString(m) } +func (*ExportFullViewingKeyResponse) ProtoMessage() {} +func (*ExportFullViewingKeyResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_8c8c99775232419d, []int{4} +} +func (m *ExportFullViewingKeyResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExportFullViewingKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExportFullViewingKeyResponse.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 *ExportFullViewingKeyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExportFullViewingKeyResponse.Merge(m, src) +} +func (m *ExportFullViewingKeyResponse) XXX_Size() int { + return m.Size() +} +func (m *ExportFullViewingKeyResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ExportFullViewingKeyResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ExportFullViewingKeyResponse proto.InternalMessageInfo + +func (m *ExportFullViewingKeyResponse) GetFullViewingKey() *v1alpha11.FullViewingKey { + if m != nil { + return m.FullViewingKey + } + return nil +} + +type ConfirmAddressRequest struct { + AddressIndex *v1alpha11.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` +} + +func (m *ConfirmAddressRequest) Reset() { *m = ConfirmAddressRequest{} } +func (m *ConfirmAddressRequest) String() string { return proto.CompactTextString(m) } +func (*ConfirmAddressRequest) ProtoMessage() {} +func (*ConfirmAddressRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_8c8c99775232419d, []int{5} +} +func (m *ConfirmAddressRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConfirmAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConfirmAddressRequest.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 *ConfirmAddressRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfirmAddressRequest.Merge(m, src) +} +func (m *ConfirmAddressRequest) XXX_Size() int { + return m.Size() +} +func (m *ConfirmAddressRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ConfirmAddressRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ConfirmAddressRequest proto.InternalMessageInfo + +func (m *ConfirmAddressRequest) GetAddressIndex() *v1alpha11.AddressIndex { + if m != nil { + return m.AddressIndex + } + return nil +} + +type ConfirmAddressResponse struct { + Address *v1alpha11.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *ConfirmAddressResponse) Reset() { *m = ConfirmAddressResponse{} } +func (m *ConfirmAddressResponse) String() string { return proto.CompactTextString(m) } +func (*ConfirmAddressResponse) ProtoMessage() {} +func (*ConfirmAddressResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_8c8c99775232419d, []int{6} +} +func (m *ConfirmAddressResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConfirmAddressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConfirmAddressResponse.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 *ConfirmAddressResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfirmAddressResponse.Merge(m, src) +} +func (m *ConfirmAddressResponse) XXX_Size() int { + return m.Size() +} +func (m *ConfirmAddressResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ConfirmAddressResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ConfirmAddressResponse proto.InternalMessageInfo + +func (m *ConfirmAddressResponse) GetAddress() *v1alpha11.Address { + if m != nil { + return m.Address + } + return nil +} + func init() { proto.RegisterType((*AuthorizeRequest)(nil), "penumbra.custody.v1alpha1.AuthorizeRequest") proto.RegisterType((*AuthorizeResponse)(nil), "penumbra.custody.v1alpha1.AuthorizeResponse") proto.RegisterType((*PreAuthorization)(nil), "penumbra.custody.v1alpha1.PreAuthorization") proto.RegisterType((*PreAuthorization_Ed25519)(nil), "penumbra.custody.v1alpha1.PreAuthorization.Ed25519") + proto.RegisterType((*ExportFullViewingKeyRequest)(nil), "penumbra.custody.v1alpha1.ExportFullViewingKeyRequest") + proto.RegisterType((*ExportFullViewingKeyResponse)(nil), "penumbra.custody.v1alpha1.ExportFullViewingKeyResponse") + proto.RegisterType((*ConfirmAddressRequest)(nil), "penumbra.custody.v1alpha1.ConfirmAddressRequest") + proto.RegisterType((*ConfirmAddressResponse)(nil), "penumbra.custody.v1alpha1.ConfirmAddressResponse") } func init() { @@ -283,41 +449,49 @@ func init() { } var fileDescriptor_8c8c99775232419d = []byte{ - // 534 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x4f, 0x6f, 0xd3, 0x30, - 0x18, 0xc6, 0x9b, 0x74, 0x62, 0xc2, 0xab, 0xa6, 0xd6, 0x48, 0xa8, 0x2b, 0x22, 0x9a, 0x2a, 0x21, - 0x26, 0x06, 0x8e, 0xda, 0xd1, 0x03, 0xe5, 0xd4, 0x0e, 0x54, 0x76, 0x40, 0x44, 0xe1, 0xaf, 0xa6, - 0x8a, 0xca, 0x75, 0x4d, 0x1b, 0x2d, 0x8d, 0x83, 0xed, 0x44, 0x2a, 0x27, 0x3e, 0xc2, 0x3e, 0xc3, - 0x24, 0x2e, 0x7c, 0x12, 0xc4, 0x69, 0x47, 0x8e, 0xa8, 0xbd, 0xf1, 0x29, 0x50, 0xfe, 0xb8, 0x49, - 0x0b, 0x85, 0xdd, 0xe2, 0xe7, 0x7d, 0xde, 0x9f, 0x5f, 0x3f, 0xb1, 0xc1, 0x5d, 0x9f, 0x7a, 0xc1, - 0x74, 0xc8, 0xb1, 0x49, 0x02, 0x21, 0xd9, 0x68, 0x66, 0x86, 0x0d, 0xec, 0xfa, 0x13, 0xdc, 0x50, - 0x02, 0xf2, 0x39, 0x93, 0x0c, 0xee, 0x29, 0x23, 0x52, 0xba, 0x32, 0xd6, 0xee, 0x65, 0x0c, 0xc6, - 0xa9, 0x49, 0xf8, 0xcc, 0x97, 0x2c, 0xc7, 0x89, 0xd7, 0x09, 0xa6, 0xf6, 0x70, 0xd5, 0x2b, 0x39, - 0xf6, 0x04, 0x26, 0xd2, 0x61, 0x5e, 0xd6, 0x90, 0x13, 0x93, 0xae, 0xfa, 0xb9, 0x0e, 0xca, 0x9d, - 0x40, 0x4e, 0x18, 0x77, 0x3e, 0x51, 0x9b, 0x7e, 0x0c, 0xa8, 0x90, 0xb0, 0x07, 0xb6, 0x7c, 0x17, - 0x7b, 0x55, 0x6d, 0x5f, 0x3b, 0xd8, 0x69, 0x1e, 0xa1, 0x6c, 0x40, 0xc6, 0x29, 0xca, 0x43, 0x14, - 0x19, 0xbd, 0xca, 0x44, 0xcb, 0xc5, 0x9e, 0x1d, 0x03, 0xe0, 0x5b, 0x50, 0xc6, 0x84, 0xb0, 0xc0, - 0x93, 0x83, 0x31, 0x67, 0x81, 0x3f, 0x70, 0x46, 0x55, 0x3d, 0x86, 0x3e, 0x58, 0x83, 0xa6, 0x47, - 0x59, 0xf2, 0x3a, 0x49, 0x5b, 0x2f, 0xea, 0x3a, 0x19, 0xd9, 0xbb, 0x78, 0x65, 0x0d, 0x4f, 0x01, - 0xf4, 0x39, 0x1d, 0xe0, 0x74, 0x72, 0x1c, 0xed, 0x2b, 0xaa, 0xc5, 0xfd, 0xe2, 0xc1, 0x4e, 0xf3, - 0x10, 0x6d, 0x0c, 0x14, 0x59, 0x9c, 0x76, 0xf2, 0x3d, 0x76, 0xc5, 0x5f, 0x53, 0x44, 0xfd, 0x3d, - 0xa8, 0xe4, 0x12, 0x11, 0x3e, 0xf3, 0x04, 0x85, 0x27, 0x60, 0x6b, 0x84, 0x25, 0x4e, 0x23, 0x69, - 0x5d, 0x25, 0x92, 0x15, 0xec, 0x13, 0x2c, 0xb1, 0x1d, 0x23, 0xea, 0x5f, 0x34, 0x50, 0x5e, 0x9f, - 0x03, 0xbe, 0x00, 0xdb, 0x74, 0xd4, 0x6c, 0xb5, 0x1a, 0x8f, 0xfe, 0x92, 0xfa, 0xff, 0x4e, 0x81, - 0x9e, 0x26, 0xad, 0xcf, 0x0a, 0xb6, 0xa2, 0xd4, 0x0e, 0xc1, 0x76, 0xaa, 0xc2, 0x5d, 0xa0, 0x87, - 0x67, 0x31, 0xb6, 0x64, 0xeb, 0xe1, 0x19, 0x2c, 0x83, 0xa2, 0x70, 0xc6, 0xf1, 0x8f, 0x28, 0xd9, - 0xd1, 0x67, 0xf7, 0x06, 0xa8, 0xfc, 0x11, 0x67, 0xf3, 0xb3, 0x06, 0x6e, 0x1e, 0x27, 0x5b, 0x5b, - 0xd1, 0x5d, 0x21, 0xcc, 0x7d, 0x49, 0x79, 0xe8, 0x10, 0x0a, 0x3f, 0x80, 0xeb, 0xcb, 0x88, 0xe0, - 0xbf, 0xf2, 0x5e, 0xbf, 0x5a, 0xb5, 0xfb, 0x57, 0x33, 0x27, 0xa9, 0x77, 0x2f, 0xf4, 0x6f, 0x73, - 0x43, 0xbb, 0x9c, 0x1b, 0xda, 0xcf, 0xb9, 0xa1, 0x9d, 0x2f, 0x8c, 0xc2, 0xe5, 0xc2, 0x28, 0xfc, - 0x58, 0x18, 0x05, 0x70, 0x9b, 0xb0, 0xe9, 0x66, 0x56, 0xb7, 0x94, 0x9f, 0xdc, 0xd2, 0x4e, 0x5f, - 0x8f, 0x1d, 0x39, 0x09, 0x86, 0x88, 0xb0, 0xa9, 0x49, 0x98, 0x98, 0x32, 0x61, 0x72, 0xea, 0xe2, - 0x19, 0xe5, 0x66, 0xd8, 0x5c, 0x7e, 0x92, 0x09, 0x76, 0x3c, 0x61, 0x6e, 0x7c, 0xb9, 0x8f, 0x53, - 0x41, 0xad, 0x2f, 0xf4, 0xa2, 0x75, 0xfc, 0xee, 0xab, 0xbe, 0x67, 0xa9, 0x41, 0xd2, 0x6d, 0xd1, - 0x9b, 0xd4, 0xf1, 0x3d, 0xab, 0xf5, 0xd3, 0x5a, 0x5f, 0xd5, 0xe6, 0xfa, 0x9d, 0x8d, 0xb5, 0x7e, - 0xcf, 0xea, 0x3e, 0xa7, 0x12, 0x47, 0x37, 0xe6, 0x97, 0x7e, 0x4b, 0xf9, 0xda, 0xed, 0xd4, 0xd8, - 0x6e, 0x2b, 0xe7, 0xf0, 0x5a, 0xfc, 0x92, 0x8f, 0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x40, 0xae, - 0xeb, 0xca, 0x71, 0x04, 0x00, 0x00, + // 657 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xcd, 0x6e, 0xd3, 0x4c, + 0x14, 0x8d, 0x9d, 0xea, 0xab, 0xbe, 0xdb, 0x52, 0xa5, 0x03, 0x54, 0x6d, 0x4a, 0xa3, 0xca, 0xe2, + 0xa7, 0xa8, 0xc8, 0x26, 0x29, 0x05, 0x11, 0x24, 0xa4, 0xa6, 0x94, 0x52, 0x21, 0xc0, 0x32, 0xb4, + 0xaa, 0xaa, 0x8a, 0x68, 0xea, 0x4c, 0x12, 0x2b, 0x8e, 0xc7, 0xcc, 0xd8, 0xa1, 0x61, 0xc7, 0x8a, + 0x2d, 0xcf, 0x50, 0x89, 0x0d, 0x2f, 0xc0, 0x2b, 0x20, 0x56, 0x5d, 0xb2, 0x44, 0xe9, 0x8e, 0xa7, + 0x40, 0x89, 0x67, 0x9a, 0xc4, 0x24, 0x21, 0xdd, 0xf9, 0x9e, 0x7b, 0xee, 0xb9, 0xbf, 0x1e, 0xb8, + 0xe5, 0x13, 0x2f, 0xac, 0x1f, 0x31, 0x6c, 0xd8, 0x21, 0x0f, 0x68, 0xa9, 0x69, 0x34, 0xb2, 0xd8, + 0xf5, 0xab, 0x38, 0x2b, 0x01, 0xdd, 0x67, 0x34, 0xa0, 0x68, 0x41, 0x12, 0x75, 0x89, 0x4b, 0x62, + 0xfa, 0x66, 0x57, 0x83, 0x32, 0x62, 0xd4, 0x48, 0x93, 0x77, 0x55, 0xda, 0x56, 0x24, 0x91, 0xbe, + 0xd7, 0xcf, 0x0b, 0x18, 0xf6, 0x38, 0xb6, 0x03, 0x87, 0x7a, 0x5d, 0x7a, 0x0f, 0x18, 0x45, 0x69, + 0xdf, 0x14, 0x48, 0x6d, 0x84, 0x41, 0x95, 0x32, 0xe7, 0x03, 0xb1, 0xc8, 0xbb, 0x90, 0xf0, 0x00, + 0x6d, 0xc3, 0x84, 0xef, 0x62, 0x6f, 0x5e, 0x59, 0x56, 0x56, 0xa6, 0x72, 0x6b, 0x7a, 0xb7, 0x38, + 0xca, 0x88, 0xde, 0x2b, 0x22, 0x95, 0xf5, 0x37, 0x5d, 0xd0, 0x74, 0xb1, 0x67, 0x75, 0x04, 0xd0, + 0x01, 0x20, 0x9f, 0x91, 0x22, 0x16, 0x09, 0x70, 0xdb, 0xcd, 0xe7, 0x93, 0xcb, 0xc9, 0x95, 0xa9, + 0xdc, 0xaa, 0x3e, 0xb4, 0x67, 0xdd, 0x64, 0x64, 0xa3, 0x37, 0xc6, 0x9a, 0xf5, 0x63, 0x08, 0xd7, + 0xde, 0xc2, 0x6c, 0x4f, 0xe1, 0xdc, 0xa7, 0x1e, 0x27, 0x68, 0x07, 0x26, 0x4a, 0x38, 0xc0, 0xa2, + 0xf2, 0xf5, 0x71, 0x2a, 0xef, 0x93, 0x7d, 0x82, 0x03, 0x6c, 0x75, 0x24, 0xb4, 0x2f, 0x0a, 0xa4, + 0xe2, 0x75, 0xa0, 0x57, 0x30, 0x49, 0x4a, 0xb9, 0xf5, 0xf5, 0xec, 0xc3, 0x01, 0xc3, 0xf9, 0x57, + 0x17, 0xfa, 0x56, 0x14, 0xfa, 0x2c, 0x61, 0x49, 0x95, 0xf4, 0x2a, 0x4c, 0x0a, 0x14, 0xcd, 0x80, + 0xda, 0xa8, 0x75, 0x64, 0xa7, 0x2d, 0xb5, 0x51, 0x43, 0x29, 0x48, 0x72, 0xa7, 0x32, 0xaf, 0x76, + 0x80, 0xf6, 0x67, 0xe1, 0x32, 0xcc, 0xfe, 0x35, 0x4e, 0x6d, 0x09, 0x16, 0xb7, 0x8e, 0x7d, 0xca, + 0x82, 0xa7, 0xa1, 0xeb, 0xee, 0x39, 0xe4, 0xbd, 0xe3, 0x55, 0x9e, 0x93, 0xa6, 0xd8, 0xa5, 0x16, + 0xc2, 0xb5, 0xc1, 0x6e, 0x31, 0xb1, 0x5d, 0x48, 0x95, 0x43, 0xd7, 0x2d, 0x36, 0x22, 0x57, 0xb1, + 0x46, 0x9a, 0xa2, 0xb5, 0xd5, 0xd8, 0xf4, 0x3a, 0xb7, 0x76, 0xde, 0x5c, 0x4c, 0x6e, 0xa6, 0xdc, + 0x67, 0x6b, 0x15, 0xb8, 0xba, 0x49, 0xbd, 0xb2, 0xc3, 0xea, 0x1b, 0xa5, 0x12, 0x23, 0x9c, 0xcb, + 0xdb, 0x7a, 0x09, 0x97, 0x70, 0x84, 0x14, 0x1d, 0xaf, 0x44, 0x8e, 0x45, 0xb2, 0xdb, 0x23, 0x93, + 0x09, 0x8d, 0x9d, 0x76, 0x80, 0x35, 0x8d, 0x7b, 0x2c, 0x6d, 0x1f, 0xe6, 0xe2, 0x89, 0x44, 0x67, + 0x8f, 0x61, 0x52, 0x30, 0x45, 0x8e, 0xeb, 0xe3, 0xe4, 0xb0, 0x64, 0x50, 0xee, 0x63, 0x12, 0xe6, + 0x36, 0xa3, 0x9d, 0x9a, 0xed, 0x7f, 0xc5, 0xa6, 0xee, 0x6b, 0xc2, 0x1a, 0x8e, 0x4d, 0x50, 0x19, + 0xfe, 0x3f, 0xbf, 0x3d, 0x34, 0xea, 0x90, 0xe3, 0xbf, 0x56, 0xfa, 0xce, 0x78, 0x64, 0xd1, 0xc2, + 0x27, 0x05, 0xae, 0x0c, 0xda, 0x1e, 0xba, 0x3f, 0x42, 0x66, 0xc4, 0x35, 0xa4, 0x1f, 0x5c, 0x38, + 0x4e, 0x54, 0x12, 0xc2, 0x4c, 0xff, 0x98, 0xd1, 0xdd, 0x11, 0x52, 0x03, 0x57, 0x9f, 0xce, 0x5e, + 0x20, 0x22, 0x4a, 0x5b, 0x38, 0x51, 0xbf, 0xb7, 0x32, 0xca, 0x69, 0x2b, 0xa3, 0xfc, 0x6a, 0x65, + 0x94, 0xcf, 0x67, 0x99, 0xc4, 0xe9, 0x59, 0x26, 0xf1, 0xf3, 0x2c, 0x93, 0x80, 0x25, 0x9b, 0xd6, + 0x87, 0x0b, 0x16, 0xa6, 0x7b, 0x57, 0x67, 0x2a, 0x07, 0xbb, 0x15, 0x27, 0xa8, 0x86, 0x47, 0xba, + 0x4d, 0xeb, 0x86, 0x4d, 0x79, 0x9d, 0x72, 0x83, 0x11, 0x17, 0x37, 0x09, 0x33, 0x1a, 0xb9, 0xf3, + 0x4f, 0xbb, 0x8a, 0x1d, 0x8f, 0x1b, 0x43, 0x9f, 0xed, 0x47, 0x02, 0x90, 0xf6, 0x89, 0x9a, 0x34, + 0x37, 0xf7, 0xbf, 0xaa, 0x0b, 0xa6, 0x2c, 0x44, 0xa4, 0xd5, 0xf7, 0x04, 0xe3, 0x47, 0xd7, 0x77, + 0x28, 0x7c, 0x87, 0xd2, 0xd7, 0x52, 0x6f, 0x0c, 0xf5, 0x1d, 0x6e, 0x9b, 0x85, 0x17, 0x24, 0xc0, + 0xed, 0xb7, 0xe8, 0xb7, 0xba, 0x28, 0x79, 0xf9, 0xbc, 0x20, 0xe6, 0xf3, 0x92, 0x79, 0xf4, 0x5f, + 0xe7, 0x29, 0x5f, 0xfb, 0x13, 0x00, 0x00, 0xff, 0xff, 0x2c, 0xdf, 0x4c, 0xa2, 0x6e, 0x06, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -334,6 +508,18 @@ const _ = grpc.SupportPackageIsVersion4 type CustodyProtocolServiceClient interface { // Requests authorization of the transaction with the given description. Authorize(ctx context.Context, in *AuthorizeRequest, opts ...grpc.CallOption) (*AuthorizeResponse, error) + // Requests the full viewing key from the custodian. + // + // Custody backends should decide whether to honor this request, and how to + // control access to it. + ExportFullViewingKey(ctx context.Context, in *ExportFullViewingKeyRequest, opts ...grpc.CallOption) (*ExportFullViewingKeyResponse, error) + // Displays an address to a user for confirmation. + // + // Custody backends with user interaction should present the address to the + // user and wait for explicit confirmation before returning. + // + // Non-interactive custody backends may return immediately. + ConfirmAddress(ctx context.Context, in *ConfirmAddressRequest, opts ...grpc.CallOption) (*ConfirmAddressResponse, error) } type custodyProtocolServiceClient struct { @@ -353,10 +539,40 @@ func (c *custodyProtocolServiceClient) Authorize(ctx context.Context, in *Author return out, nil } +func (c *custodyProtocolServiceClient) ExportFullViewingKey(ctx context.Context, in *ExportFullViewingKeyRequest, opts ...grpc.CallOption) (*ExportFullViewingKeyResponse, error) { + out := new(ExportFullViewingKeyResponse) + err := c.cc.Invoke(ctx, "/penumbra.custody.v1alpha1.CustodyProtocolService/ExportFullViewingKey", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *custodyProtocolServiceClient) ConfirmAddress(ctx context.Context, in *ConfirmAddressRequest, opts ...grpc.CallOption) (*ConfirmAddressResponse, error) { + out := new(ConfirmAddressResponse) + err := c.cc.Invoke(ctx, "/penumbra.custody.v1alpha1.CustodyProtocolService/ConfirmAddress", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // CustodyProtocolServiceServer is the server API for CustodyProtocolService service. type CustodyProtocolServiceServer interface { // Requests authorization of the transaction with the given description. Authorize(context.Context, *AuthorizeRequest) (*AuthorizeResponse, error) + // Requests the full viewing key from the custodian. + // + // Custody backends should decide whether to honor this request, and how to + // control access to it. + ExportFullViewingKey(context.Context, *ExportFullViewingKeyRequest) (*ExportFullViewingKeyResponse, error) + // Displays an address to a user for confirmation. + // + // Custody backends with user interaction should present the address to the + // user and wait for explicit confirmation before returning. + // + // Non-interactive custody backends may return immediately. + ConfirmAddress(context.Context, *ConfirmAddressRequest) (*ConfirmAddressResponse, error) } // UnimplementedCustodyProtocolServiceServer can be embedded to have forward compatible implementations. @@ -366,6 +582,12 @@ type UnimplementedCustodyProtocolServiceServer struct { func (*UnimplementedCustodyProtocolServiceServer) Authorize(ctx context.Context, req *AuthorizeRequest) (*AuthorizeResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Authorize not implemented") } +func (*UnimplementedCustodyProtocolServiceServer) ExportFullViewingKey(ctx context.Context, req *ExportFullViewingKeyRequest) (*ExportFullViewingKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ExportFullViewingKey not implemented") +} +func (*UnimplementedCustodyProtocolServiceServer) ConfirmAddress(ctx context.Context, req *ConfirmAddressRequest) (*ConfirmAddressResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ConfirmAddress not implemented") +} func RegisterCustodyProtocolServiceServer(s grpc1.Server, srv CustodyProtocolServiceServer) { s.RegisterService(&_CustodyProtocolService_serviceDesc, srv) @@ -389,6 +611,42 @@ func _CustodyProtocolService_Authorize_Handler(srv interface{}, ctx context.Cont return interceptor(ctx, in, info, handler) } +func _CustodyProtocolService_ExportFullViewingKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExportFullViewingKeyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CustodyProtocolServiceServer).ExportFullViewingKey(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.custody.v1alpha1.CustodyProtocolService/ExportFullViewingKey", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CustodyProtocolServiceServer).ExportFullViewingKey(ctx, req.(*ExportFullViewingKeyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CustodyProtocolService_ConfirmAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ConfirmAddressRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CustodyProtocolServiceServer).ConfirmAddress(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.custody.v1alpha1.CustodyProtocolService/ConfirmAddress", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CustodyProtocolServiceServer).ConfirmAddress(ctx, req.(*ConfirmAddressRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _CustodyProtocolService_serviceDesc = grpc.ServiceDesc{ ServiceName: "penumbra.custody.v1alpha1.CustodyProtocolService", HandlerType: (*CustodyProtocolServiceServer)(nil), @@ -397,6 +655,14 @@ var _CustodyProtocolService_serviceDesc = grpc.ServiceDesc{ MethodName: "Authorize", Handler: _CustodyProtocolService_Authorize_Handler, }, + { + MethodName: "ExportFullViewingKey", + Handler: _CustodyProtocolService_ExportFullViewingKey_Handler, + }, + { + MethodName: "ConfirmAddress", + Handler: _CustodyProtocolService_ConfirmAddress_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "penumbra/custody/v1alpha1/custody.proto", @@ -436,18 +702,6 @@ func (m *AuthorizeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x1a } } - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCustody(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } if m.Plan != nil { { size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i]) @@ -588,80 +842,204 @@ func (m *PreAuthorization_Ed25519) MarshalToSizedBuffer(dAtA []byte) (int, error return len(dAtA) - i, nil } -func encodeVarintCustody(dAtA []byte, offset int, v uint64) int { - offset -= sovCustody(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *ExportFullViewingKeyRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *AuthorizeRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Plan != nil { - l = m.Plan.Size() - n += 1 + l + sovCustody(uint64(l)) - } - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() - n += 1 + l + sovCustody(uint64(l)) - } - if len(m.PreAuthorizations) > 0 { - for _, e := range m.PreAuthorizations { - l = e.Size() - n += 1 + l + sovCustody(uint64(l)) - } - } - return n + +func (m *ExportFullViewingKeyRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AuthorizeResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *ExportFullViewingKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Data != nil { - l = m.Data.Size() - n += 1 + l + sovCustody(uint64(l)) - } - return n + return len(dAtA) - i, nil } -func (m *PreAuthorization) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PreAuthorization != nil { - n += m.PreAuthorization.Size() +func (m *ExportFullViewingKeyResponse) 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 n + return dAtA[:n], nil } -func (m *PreAuthorization_Ed25519_) Size() (n int) { - if m == nil { - return 0 - } +func (m *ExportFullViewingKeyResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExportFullViewingKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Ed25519 != nil { - l = m.Ed25519.Size() - n += 1 + l + sovCustody(uint64(l)) + if m.FullViewingKey != nil { + { + size, err := m.FullViewingKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCustody(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *PreAuthorization_Ed25519) Size() (n int) { - if m == nil { - return 0 + +func (m *ConfirmAddressRequest) 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 *ConfirmAddressRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConfirmAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AddressIndex != nil { + { + size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCustody(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ConfirmAddressResponse) 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 *ConfirmAddressResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConfirmAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Address != nil { + { + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCustody(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintCustody(dAtA []byte, offset int, v uint64) int { + offset -= sovCustody(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *AuthorizeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Plan != nil { + l = m.Plan.Size() + n += 1 + l + sovCustody(uint64(l)) + } + if len(m.PreAuthorizations) > 0 { + for _, e := range m.PreAuthorizations { + l = e.Size() + n += 1 + l + sovCustody(uint64(l)) + } + } + return n +} + +func (m *AuthorizeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.Size() + n += 1 + l + sovCustody(uint64(l)) + } + return n +} + +func (m *PreAuthorization) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PreAuthorization != nil { + n += m.PreAuthorization.Size() + } + return n +} + +func (m *PreAuthorization_Ed25519_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Ed25519 != nil { + l = m.Ed25519.Size() + n += 1 + l + sovCustody(uint64(l)) + } + return n +} +func (m *PreAuthorization_Ed25519) Size() (n int) { + if m == nil { + return 0 } var l int _ = l @@ -676,6 +1054,54 @@ func (m *PreAuthorization_Ed25519) Size() (n int) { return n } +func (m *ExportFullViewingKeyRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *ExportFullViewingKeyResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FullViewingKey != nil { + l = m.FullViewingKey.Size() + n += 1 + l + sovCustody(uint64(l)) + } + return n +} + +func (m *ConfirmAddressRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AddressIndex != nil { + l = m.AddressIndex.Size() + n += 1 + l + sovCustody(uint64(l)) + } + return n +} + +func (m *ConfirmAddressResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Address != nil { + l = m.Address.Size() + n += 1 + l + sovCustody(uint64(l)) + } + return n +} + func sovCustody(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -747,42 +1173,6 @@ func (m *AuthorizeRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCustody - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCustody - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCustody - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.AccountGroupId == nil { - m.AccountGroupId = &v1alpha11.AccountGroupId{} - } - if err := m.AccountGroupId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PreAuthorizations", wireType) @@ -1127,6 +1517,314 @@ func (m *PreAuthorization_Ed25519) Unmarshal(dAtA []byte) error { } return nil } +func (m *ExportFullViewingKeyRequest) 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 ErrIntOverflowCustody + } + 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: ExportFullViewingKeyRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExportFullViewingKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipCustody(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCustody + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExportFullViewingKeyResponse) 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 ErrIntOverflowCustody + } + 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: ExportFullViewingKeyResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExportFullViewingKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FullViewingKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCustody + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCustody + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCustody + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FullViewingKey == nil { + m.FullViewingKey = &v1alpha11.FullViewingKey{} + } + if err := m.FullViewingKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCustody(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCustody + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfirmAddressRequest) 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 ErrIntOverflowCustody + } + 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: ConfirmAddressRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfirmAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCustody + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCustody + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCustody + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AddressIndex == nil { + m.AddressIndex = &v1alpha11.AddressIndex{} + } + if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCustody(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCustody + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfirmAddressResponse) 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 ErrIntOverflowCustody + } + 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: ConfirmAddressResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfirmAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCustody + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCustody + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCustody + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &v1alpha11.Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCustody(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCustody + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipCustody(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/relayer/chains/penumbra/event_parser.go b/relayer/chains/penumbra/event_parser.go deleted file mode 100644 index 19707325b..000000000 --- a/relayer/chains/penumbra/event_parser.go +++ /dev/null @@ -1,16 +0,0 @@ -package penumbra - -import ( - abci "github.com/cometbft/cometbft/abci/types" - "github.com/cosmos/relayer/v2/relayer/chains" -) - -func (ccp *PenumbraChainProcessor) ibcMessagesFromBlockEvents( - beginBlockEvents, endBlockEvents []abci.Event, - height uint64, base64Encoded bool, -) (res []chains.IbcMessage) { - chainID := ccp.chainProvider.ChainId() - res = append(res, chains.IbcMessagesFromEvents(ccp.log, beginBlockEvents, chainID, height, base64Encoded)...) - res = append(res, chains.IbcMessagesFromEvents(ccp.log, endBlockEvents, chainID, height, base64Encoded)...) - return res -} diff --git a/relayer/chains/penumbra/grpc_query.go b/relayer/chains/penumbra/grpc_query.go index 70c375c81..9a3de2229 100644 --- a/relayer/chains/penumbra/grpc_query.go +++ b/relayer/chains/penumbra/grpc_query.go @@ -8,7 +8,13 @@ import ( "sync" "time" + sdkerrors "cosmossdk.io/errors" abci "github.com/cometbft/cometbft/abci/types" + "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + legacyerrors "github.com/cosmos/cosmos-sdk/types/errors" + grpctypes "github.com/cosmos/cosmos-sdk/types/grpc" + "github.com/cosmos/cosmos-sdk/types/tx" gogogrpc "github.com/cosmos/gogoproto/grpc" "github.com/cosmos/relayer/v2/relayer/provider" "google.golang.org/grpc" @@ -17,12 +23,6 @@ import ( "google.golang.org/grpc/encoding/proto" "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" - - "github.com/cosmos/cosmos-sdk/codec/types" - sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" - grpctypes "github.com/cosmos/cosmos-sdk/types/grpc" - "github.com/cosmos/cosmos-sdk/types/tx" ) var _ gogogrpc.ClientConn = &PenumbraProvider{} @@ -37,17 +37,17 @@ func (cc *PenumbraProvider) Invoke(ctx context.Context, method string, req, repl // In both cases, we don't allow empty request req (it will panic unexpectedly). if reflect.ValueOf(req).IsNil() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "request cannot be nil") + return sdkerrors.Wrap(legacyerrors.ErrInvalidRequest, "request cannot be nil") } // Case 1. Broadcasting a Tx. if reqProto, ok := req.(*tx.BroadcastTxRequest); ok { if !ok { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxRequest)(nil), req) + return sdkerrors.Wrapf(legacyerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxRequest)(nil), req) } resProto, ok := reply.(*tx.BroadcastTxResponse) if !ok { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxResponse)(nil), req) + return sdkerrors.Wrapf(legacyerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxResponse)(nil), req) } broadcastRes, err := cc.TxServiceBroadcast(ctx, reqProto) @@ -108,7 +108,7 @@ func (cc *PenumbraProvider) RunGRPCQuery(ctx context.Context, method string, req } if height < 0 { return abci.ResponseQuery{}, nil, sdkerrors.Wrapf( - sdkerrors.ErrInvalidRequest, + legacyerrors.ErrInvalidRequest, "client.Context.Invoke: height (%d) from %q must be >= 0", height, grpctypes.GRPCBlockHeightHeader) } @@ -142,6 +142,7 @@ func (cc *PenumbraProvider) RunGRPCQuery(ctx context.Context, method string, req // HeaderCallOption, then we manually set the value of that header to the // metadata. md = metadata.Pairs(grpctypes.GRPCBlockHeightHeader, strconv.FormatInt(abciRes.Height, 10)) + return abciRes, md, nil } diff --git a/relayer/chains/penumbra/log.go b/relayer/chains/penumbra/log.go index 65a9d8b26..32d249f87 100644 --- a/relayer/chains/penumbra/log.go +++ b/relayer/chains/penumbra/log.go @@ -3,12 +3,13 @@ package penumbra import ( "reflect" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" typestx "github.com/cosmos/cosmos-sdk/types/tx" - feetypes "github.com/cosmos/ibc-go/v7/modules/apps/29-fee/types" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" + feetypes "github.com/cosmos/ibc-go/v8/modules/apps/29-fee/types" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" "go.uber.org/zap/zapcore" @@ -90,11 +91,13 @@ func (cc *PenumbraProvider) LogSuccessTx(res *sdk.TxResponse, msgs []provider.Re // Extract fees and fee_payer if present ir := types.NewInterfaceRegistry() + cdc := codec.NewProtoCodec(ir) + var m sdk.Msg if err := ir.UnpackAny(res.Tx, &m); err == nil { if tx, ok := m.(*typestx.Tx); ok { fields = append(fields, zap.Stringer("fees", tx.GetFee())) - if feePayer := getFeePayer(tx); feePayer != "" { + if feePayer := getFeePayer(cc.log, cdc, tx); feePayer != "" { fields = append(fields, zap.String("fee_payer", feePayer)) } } else { @@ -132,7 +135,7 @@ func msgTypesField(msgs []provider.RelayerMessage) zap.Field { // getFeePayer returns the bech32 address of the fee payer of a transaction. // This uses the fee payer field if set, // otherwise falls back to the address of whoever signed the first message. -func getFeePayer(tx *typestx.Tx) string { +func getFeePayer(log *zap.Logger, cdc *codec.ProtoCodec, tx *typestx.Tx) string { payer := tx.AuthInfo.Fee.Payer if payer != "" { return payer @@ -165,6 +168,12 @@ func getFeePayer(tx *typestx.Tx) string { case *feetypes.MsgPayPacketFeeAsync: return firstMsg.PacketFee.RefundAddress default: - return firstMsg.GetSigners()[0].String() + signers, _, err := cdc.GetMsgV1Signers(firstMsg) + if err != nil { + log.Info("Could not get signers for msg when attempting to get the fee payer", zap.Error(err)) + return "" + } + + return string(signers[0]) } } diff --git a/relayer/chains/penumbra/message_handlers.go b/relayer/chains/penumbra/message_handlers.go index a67071190..1cdbe1867 100644 --- a/relayer/chains/penumbra/message_handlers.go +++ b/relayer/chains/penumbra/message_handlers.go @@ -1,8 +1,8 @@ package penumbra import ( - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/chains" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" diff --git a/relayer/chains/penumbra/msg.go b/relayer/chains/penumbra/msg.go index 951529b0a..460cdaf07 100644 --- a/relayer/chains/penumbra/msg.go +++ b/relayer/chains/penumbra/msg.go @@ -6,7 +6,7 @@ import ( "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/gogoproto/proto" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/chains/cosmos" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap/zapcore" diff --git a/relayer/chains/penumbra/penumbra_chain_processor.go b/relayer/chains/penumbra/penumbra_chain_processor.go index ffa1515db..2944a4570 100644 --- a/relayer/chains/penumbra/penumbra_chain_processor.go +++ b/relayer/chains/penumbra/penumbra_chain_processor.go @@ -8,14 +8,13 @@ import ( "github.com/avast/retry-go/v4" tmproto "github.com/cometbft/cometbft/proto/tendermint/types" - ctypes "github.com/cometbft/cometbft/rpc/core/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + coretypes "github.com/cometbft/cometbft/rpc/core/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + "github.com/cosmos/relayer/v2/relayer/chains" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" - - "github.com/cosmos/relayer/v2/relayer/chains" "go.uber.org/zap" "golang.org/x/sync/errgroup" ) @@ -319,26 +318,33 @@ func (pcp *PenumbraChainProcessor) queryCycle(ctx context.Context, persistence * ppChanged := false - var latestHeader PenumbraIBCHeader + var latestHeader provider.TendermintIBCHeader newLatestQueriedBlock := persistence.latestQueriedBlock chainID := pcp.chainProvider.ChainId() for i := persistence.latestQueriedBlock + 1; i <= persistence.latestHeight; i++ { - var eg errgroup.Group - var blockRes *ctypes.ResultBlockResults - var ibcHeader provider.IBCHeader + var ( + eg errgroup.Group + blockRes *coretypes.ResultBlockResults + ibcHeader provider.IBCHeader + ) + i := i + eg.Go(func() (err error) { queryCtx, cancelQueryCtx := context.WithTimeout(ctx, blockResultsQueryTimeout) defer cancelQueryCtx() + blockRes, err = pcp.chainProvider.RPCClient.BlockResults(queryCtx, &i) return err }) + eg.Go(func() (err error) { queryCtx, cancelQueryCtx := context.WithTimeout(ctx, queryTimeout) defer cancelQueryCtx() + ibcHeader, err = pcp.chainProvider.QueryIBCHeader(queryCtx, i) return err }) @@ -348,7 +354,7 @@ func (pcp *PenumbraChainProcessor) queryCycle(ctx context.Context, persistence * break } - latestHeader = ibcHeader.(PenumbraIBCHeader) + latestHeader = ibcHeader.(provider.TendermintIBCHeader) heightUint64 := uint64(i) @@ -360,7 +366,8 @@ func (pcp *PenumbraChainProcessor) queryCycle(ctx context.Context, persistence * ibcHeaderCache[heightUint64] = latestHeader ppChanged = true - blockMsgs := pcp.ibcMessagesFromBlockEvents(blockRes.BeginBlockEvents, blockRes.EndBlockEvents, heightUint64, true) + blockMsgs := chains.IbcMessagesFromEvents(pcp.log, blockRes.FinalizeBlockEvents, chainID, heightUint64) + for _, m := range blockMsgs { pcp.handleMessage(m, ibcMessagesCache) } @@ -370,7 +377,7 @@ func (pcp *PenumbraChainProcessor) queryCycle(ctx context.Context, persistence * // tx was not successful continue } - messages := chains.IbcMessagesFromEvents(pcp.log, tx.Events, chainID, heightUint64, true) + messages := chains.IbcMessagesFromEvents(pcp.log, tx.Events, chainID, heightUint64) for _, m := range messages { pcp.handleMessage(m, ibcMessagesCache) diff --git a/relayer/chains/penumbra/provider.go b/relayer/chains/penumbra/provider.go index 19176559d..345205045 100644 --- a/relayer/chains/penumbra/provider.go +++ b/relayer/chains/penumbra/provider.go @@ -10,7 +10,6 @@ import ( provtypes "github.com/cometbft/cometbft/light/provider" prov "github.com/cometbft/cometbft/light/provider/http" - rpcclient "github.com/cometbft/cometbft/rpc/client" rpchttp "github.com/cometbft/cometbft/rpc/client/http" jsonrpcclient "github.com/cometbft/cometbft/rpc/jsonrpc/client" libclient "github.com/cometbft/cometbft/rpc/jsonrpc/client" @@ -18,14 +17,15 @@ import ( "github.com/cosmos/cosmos-sdk/crypto/keyring" "github.com/cosmos/cosmos-sdk/types/module" "github.com/cosmos/gogoproto/proto" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - commitmenttypes "github.com/cosmos/ibc-go/v7/modules/core/23-commitment/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" - tmclient "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + commitmenttypes "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + tmclient "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" + cwrapper "github.com/cosmos/relayer/v2/client" "github.com/cosmos/relayer/v2/relayer/codecs/ethermint" "github.com/cosmos/relayer/v2/relayer/provider" + "github.com/strangelove-ventures/cometbft-client/client" "go.uber.org/zap" - "golang.org/x/mod/semver" ) var ( @@ -34,7 +34,10 @@ var ( _ provider.ProviderConfig = &PenumbraProviderConfig{} ) -const cometEncodingThreshold = "v0.37.0-alpha" +const ( + cometEncodingThreshold = "v0.37.0-alpha" + cometBlockResultsThreshold = "v0.38.0-alpha" +) type PenumbraProviderConfig struct { KeyDirectory string `json:"key-directory" yaml:"key-directory"` @@ -137,15 +140,12 @@ type PenumbraProvider struct { PCfg PenumbraProviderConfig Keybase keyring.Keyring KeyringOptions []keyring.Option - RPCClient rpcclient.Client + RPCClient cwrapper.RPCClient LightProvider provtypes.Provider Input io.Reader Output io.Writer Codec Codec RPCCaller jsonrpcclient.Caller - - // for comet < v0.37, decode tm events as base64 - cometLegacyEncoding bool } func (cc *PenumbraProvider) ProviderConfig() provider.ProviderConfig { @@ -173,7 +173,7 @@ func (cc *PenumbraProvider) Timeout() string { } func (cc *PenumbraProvider) CommitmentPrefix() commitmenttypes.MerklePrefix { - return commitmenttypes.NewMerklePrefix([]byte("PenumbraAppHash")) + return commitmenttypes.NewMerklePrefix([]byte("ibc-data")) } // Address returns the chains configured address as a string @@ -196,7 +196,7 @@ func (cc *PenumbraProvider) Address() (string, error) { return out, err } -func (cc *PenumbraProvider) TrustingPeriod(ctx context.Context, overrideUnbondingPeriod time.Duration) (time.Duration, error) { +func (cc *PenumbraProvider) TrustingPeriod(ctx context.Context, overrideUnbondingPeriod time.Duration, percentage int64) (time.Duration, error) { // TODO return time.Hour * 2, nil /* @@ -211,7 +211,7 @@ func (cc *PenumbraProvider) TrustingPeriod(ctx context.Context, overrideUnbondin // by converting int64 to float64. // Use integer math the whole time, first reducing by a factor of 100 // and then re-growing by 85x. - tp := res.UnbondingTime / 100 * 85 + tp := res.UnbondingTime / 100 * 85 // TODO: replace with percentage // And we only want the trusting period to be whole hours. return tp.Truncate(time.Hour), nil @@ -249,28 +249,20 @@ func (cc *PenumbraProvider) Init(ctx context.Context) error { return err } - rpcClient, err := newRPCClient(cc.PCfg.RPCAddr, timeout) + lightprovider, err := prov.New(cc.PCfg.ChainID, cc.PCfg.RPCAddr) if err != nil { return err } - lightprovider, err := prov.New(cc.PCfg.ChainID, cc.PCfg.RPCAddr) + c, err := client.NewClient(cc.PCfg.RPCAddr, timeout) if err != nil { return err } - cc.RPCClient = rpcClient + cc.RPCClient = cwrapper.NewRPCClient(c) cc.LightProvider = lightprovider cc.Keybase = keybase - status, err := cc.QueryStatus(ctx) - if err != nil { - // Operations can occur before the node URL is added to the config, so noop here. - return nil - } - - cc.setCometVersion(cc.log, status.NodeInfo.Version) - return nil } @@ -323,14 +315,6 @@ func toPenumbraPacket(pi provider.PacketInfo) chantypes.Packet { } } -func (cc *PenumbraProvider) setCometVersion(log *zap.Logger, version string) { - cc.cometLegacyEncoding = cc.legacyEncodedEvents(log, version) -} - -func (cc *PenumbraProvider) legacyEncodedEvents(log *zap.Logger, version string) bool { - return semver.Compare("v"+version, cometEncodingThreshold) < 0 -} - // keysDir returns a string representing the path on the local filesystem where the keystore will be initialized. func keysDir(home, chainID string) string { return path.Join(home, "keys", chainID) diff --git a/relayer/chains/penumbra/query.go b/relayer/chains/penumbra/query.go index 4ba47ec4d..9aa86c5e3 100644 --- a/relayer/chains/penumbra/query.go +++ b/relayer/chains/penumbra/query.go @@ -9,24 +9,24 @@ import ( "strings" "time" + sdkerrors "cosmossdk.io/errors" + upgradetypes "cosmossdk.io/x/upgrade/types" abci "github.com/cometbft/cometbft/abci/types" coretypes "github.com/cometbft/cometbft/rpc/core/types" tmtypes "github.com/cometbft/cometbft/types" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" querytypes "github.com/cosmos/cosmos-sdk/types/query" bankTypes "github.com/cosmos/cosmos-sdk/x/bank/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" - upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - commitmenttypes "github.com/cosmos/ibc-go/v7/modules/core/23-commitment/types" - host "github.com/cosmos/ibc-go/v7/modules/core/24-host" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" - tmclient "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + commitmenttypes "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types" + host "github.com/cosmos/ibc-go/v8/modules/core/24-host" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + tmclient "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" "github.com/cosmos/relayer/v2/relayer/chains" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" @@ -47,7 +47,7 @@ func (cc *PenumbraProvider) QueryTx(ctx context.Context, hashHex string) (*provi return nil, err } - events := parseEventsFromResponseDeliverTx(resp.TxResult) + events := parseEventsFromResponseDeliverTx(resp.TxResult.Events) return &provider.RelayerTxResponse{ Height: resp.Height, @@ -81,7 +81,7 @@ func (cc *PenumbraProvider) QueryTxs(ctx context.Context, page, limit int, event // at most, one tx in the response. Because of this we don't want to initialize the slice with an initial size. var txResps []*provider.RelayerTxResponse for _, tx := range res.Txs { - relayerEvents := parseEventsFromResponseDeliverTx(tx.TxResult) + relayerEvents := parseEventsFromResponseDeliverTx(tx.TxResult.Events) txResps = append(txResps, &provider.RelayerTxResponse{ Height: tx.Height, TxHash: string(tx.Hash), @@ -95,14 +95,15 @@ func (cc *PenumbraProvider) QueryTxs(ctx context.Context, page, limit int, event // parseEventsFromResponseDeliverTx parses the events from a ResponseDeliverTx and builds a slice // of provider.RelayerEvent's. -func parseEventsFromResponseDeliverTx(resp abci.ResponseDeliverTx) []provider.RelayerEvent { +func parseEventsFromResponseDeliverTx(resp []abci.Event) []provider.RelayerEvent { var events []provider.RelayerEvent - for _, event := range resp.Events { + for _, event := range resp { attributes := make(map[string]string) for _, attribute := range event.Attributes { - attributes[string(attribute.Key)] = string(attribute.Value) + attributes[attribute.Key] = attribute.Value } + events = append(events, provider.RelayerEvent{ EventType: event.Type, Attributes: attributes, @@ -174,6 +175,8 @@ func (cc *PenumbraProvider) QueryTendermintProof(ctx context.Context, height int height-- } + key = append([]byte("ibc-data/"), key...) + cc.log.Debug("Querying K/V", zap.String("ChainId", cc.ChainId()), zap.Int64("Height", height), zap.String("Key", string(key))) req := abci.RequestQuery{ Path: "state/key", @@ -919,10 +922,11 @@ func (cc *PenumbraProvider) queryIBCMessages(ctx context.Context, log *zap.Logge if err != nil { return nil, err } + var ibcMsgs []chains.IbcMessage chainID := cc.ChainId() for _, tx := range res.Txs { - ibcMsgs = append(ibcMsgs, chains.IbcMessagesFromEvents(log, tx.TxResult.Events, chainID, 0, true)...) + ibcMsgs = append(ibcMsgs, chains.IbcMessagesFromEvents(log, tx.TxResult.Events, chainID, 0)...) } return ibcMsgs, nil diff --git a/relayer/chains/penumbra/relayer_packets.go b/relayer/chains/penumbra/relayer_packets.go index 7e5057037..b8083bd7d 100644 --- a/relayer/chains/penumbra/relayer_packets.go +++ b/relayer/chains/penumbra/relayer_packets.go @@ -4,8 +4,8 @@ import ( "context" "fmt" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/provider" ) diff --git a/relayer/chains/penumbra/storage/v1alpha1/storage.pb.go b/relayer/chains/penumbra/storage/v1alpha1/storage.pb.go new file mode 100644 index 000000000..a7c67d143 --- /dev/null +++ b/relayer/chains/penumbra/storage/v1alpha1/storage.pb.go @@ -0,0 +1,1455 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/storage/v1alpha1/storage.proto + +package storagev1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + types "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +// Performs a key-value query, either by key or by key hash. +// +// Proofs are only supported by key. +type KeyValueRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // If set, the key to fetch from storage. + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + // whether to return a proof + Proof bool `protobuf:"varint,3,opt,name=proof,proto3" json:"proof,omitempty"` +} + +func (m *KeyValueRequest) Reset() { *m = KeyValueRequest{} } +func (m *KeyValueRequest) String() string { return proto.CompactTextString(m) } +func (*KeyValueRequest) ProtoMessage() {} +func (*KeyValueRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_02c76aead37ce84a, []int{0} +} +func (m *KeyValueRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyValueRequest.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 *KeyValueRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyValueRequest.Merge(m, src) +} +func (m *KeyValueRequest) XXX_Size() int { + return m.Size() +} +func (m *KeyValueRequest) XXX_DiscardUnknown() { + xxx_messageInfo_KeyValueRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyValueRequest proto.InternalMessageInfo + +func (m *KeyValueRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *KeyValueRequest) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *KeyValueRequest) GetProof() bool { + if m != nil { + return m.Proof + } + return false +} + +type KeyValueResponse struct { + // The value corresponding to the specified key, if it was found. + Value *KeyValueResponse_Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + // A proof of existence or non-existence. + Proof *types.MerkleProof `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` +} + +func (m *KeyValueResponse) Reset() { *m = KeyValueResponse{} } +func (m *KeyValueResponse) String() string { return proto.CompactTextString(m) } +func (*KeyValueResponse) ProtoMessage() {} +func (*KeyValueResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_02c76aead37ce84a, []int{1} +} +func (m *KeyValueResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyValueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyValueResponse.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 *KeyValueResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyValueResponse.Merge(m, src) +} +func (m *KeyValueResponse) XXX_Size() int { + return m.Size() +} +func (m *KeyValueResponse) XXX_DiscardUnknown() { + xxx_messageInfo_KeyValueResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyValueResponse proto.InternalMessageInfo + +func (m *KeyValueResponse) GetValue() *KeyValueResponse_Value { + if m != nil { + return m.Value + } + return nil +} + +func (m *KeyValueResponse) GetProof() *types.MerkleProof { + if m != nil { + return m.Proof + } + return nil +} + +type KeyValueResponse_Value struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *KeyValueResponse_Value) Reset() { *m = KeyValueResponse_Value{} } +func (m *KeyValueResponse_Value) String() string { return proto.CompactTextString(m) } +func (*KeyValueResponse_Value) ProtoMessage() {} +func (*KeyValueResponse_Value) Descriptor() ([]byte, []int) { + return fileDescriptor_02c76aead37ce84a, []int{1, 0} +} +func (m *KeyValueResponse_Value) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyValueResponse_Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyValueResponse_Value.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 *KeyValueResponse_Value) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyValueResponse_Value.Merge(m, src) +} +func (m *KeyValueResponse_Value) XXX_Size() int { + return m.Size() +} +func (m *KeyValueResponse_Value) XXX_DiscardUnknown() { + xxx_messageInfo_KeyValueResponse_Value.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyValueResponse_Value proto.InternalMessageInfo + +func (m *KeyValueResponse_Value) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// Performs a prefixed key-value query, by string prefix. +type PrefixValueRequest struct { + // The expected chain id (empty string if no expectation). + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + // The prefix to fetch subkeys from storage. + Prefix string `protobuf:"bytes,2,opt,name=prefix,proto3" json:"prefix,omitempty"` +} + +func (m *PrefixValueRequest) Reset() { *m = PrefixValueRequest{} } +func (m *PrefixValueRequest) String() string { return proto.CompactTextString(m) } +func (*PrefixValueRequest) ProtoMessage() {} +func (*PrefixValueRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_02c76aead37ce84a, []int{2} +} +func (m *PrefixValueRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PrefixValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PrefixValueRequest.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 *PrefixValueRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PrefixValueRequest.Merge(m, src) +} +func (m *PrefixValueRequest) XXX_Size() int { + return m.Size() +} +func (m *PrefixValueRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PrefixValueRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_PrefixValueRequest proto.InternalMessageInfo + +func (m *PrefixValueRequest) GetChainId() string { + if m != nil { + return m.ChainId + } + return "" +} + +func (m *PrefixValueRequest) GetPrefix() string { + if m != nil { + return m.Prefix + } + return "" +} + +type PrefixValueResponse struct { + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *PrefixValueResponse) Reset() { *m = PrefixValueResponse{} } +func (m *PrefixValueResponse) String() string { return proto.CompactTextString(m) } +func (*PrefixValueResponse) ProtoMessage() {} +func (*PrefixValueResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_02c76aead37ce84a, []int{3} +} +func (m *PrefixValueResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PrefixValueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PrefixValueResponse.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 *PrefixValueResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PrefixValueResponse.Merge(m, src) +} +func (m *PrefixValueResponse) XXX_Size() int { + return m.Size() +} +func (m *PrefixValueResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PrefixValueResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_PrefixValueResponse proto.InternalMessageInfo + +func (m *PrefixValueResponse) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *PrefixValueResponse) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func init() { + proto.RegisterType((*KeyValueRequest)(nil), "penumbra.storage.v1alpha1.KeyValueRequest") + proto.RegisterType((*KeyValueResponse)(nil), "penumbra.storage.v1alpha1.KeyValueResponse") + proto.RegisterType((*KeyValueResponse_Value)(nil), "penumbra.storage.v1alpha1.KeyValueResponse.Value") + proto.RegisterType((*PrefixValueRequest)(nil), "penumbra.storage.v1alpha1.PrefixValueRequest") + proto.RegisterType((*PrefixValueResponse)(nil), "penumbra.storage.v1alpha1.PrefixValueResponse") +} + +func init() { + proto.RegisterFile("penumbra/storage/v1alpha1/storage.proto", fileDescriptor_02c76aead37ce84a) +} + +var fileDescriptor_02c76aead37ce84a = []byte{ + // 490 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xcf, 0x6b, 0x13, 0x41, + 0x14, 0xce, 0x6c, 0x48, 0x8d, 0xd3, 0x80, 0x65, 0x14, 0x49, 0x22, 0x5d, 0x4a, 0x44, 0x5a, 0x14, + 0x67, 0xdd, 0x78, 0x32, 0xe2, 0x25, 0x97, 0x20, 0x52, 0x58, 0x13, 0x2d, 0x22, 0x01, 0x99, 0x9d, + 0xbc, 0x36, 0x4b, 0xb3, 0x3b, 0xeb, 0xec, 0x0f, 0xcc, 0x7f, 0xe1, 0xdf, 0xd0, 0xa3, 0x77, 0xff, + 0x07, 0xf1, 0xd4, 0xa3, 0x47, 0x49, 0x6e, 0xfe, 0x15, 0xb2, 0xb3, 0x33, 0x26, 0x55, 0x22, 0xe9, + 0x6d, 0xdf, 0xf7, 0xbe, 0xf7, 0xbd, 0x6f, 0xbe, 0xd9, 0xc1, 0x87, 0x31, 0x44, 0x59, 0xe8, 0x4b, + 0xe6, 0x24, 0xa9, 0x90, 0xec, 0x0c, 0x9c, 0xdc, 0x65, 0xb3, 0x78, 0xca, 0x5c, 0x03, 0xd0, 0x58, + 0x8a, 0x54, 0x90, 0x96, 0x21, 0x52, 0x83, 0x1b, 0x62, 0xfb, 0x30, 0xf0, 0xb9, 0xc3, 0x85, 0x04, + 0x87, 0x8b, 0x30, 0x0c, 0xd2, 0x10, 0xa2, 0xd4, 0xc9, 0xdd, 0xb5, 0xaa, 0xd4, 0xe8, 0xbc, 0xc1, + 0xb7, 0x5e, 0xc1, 0xfc, 0x84, 0xcd, 0x32, 0x18, 0xc2, 0xc7, 0x0c, 0x92, 0x94, 0xb4, 0x70, 0x9d, + 0x4f, 0x59, 0x10, 0x7d, 0x08, 0x26, 0x4d, 0x74, 0x80, 0x8e, 0x6e, 0x0e, 0x6f, 0xa8, 0xfa, 0xe5, + 0x84, 0xec, 0xe1, 0xea, 0x39, 0xcc, 0x9b, 0x96, 0x42, 0x8b, 0x4f, 0x72, 0x07, 0xd7, 0x62, 0x29, + 0xc4, 0x69, 0xb3, 0x7a, 0x80, 0x8e, 0xea, 0xc3, 0xb2, 0xe8, 0x7c, 0x45, 0x78, 0x6f, 0x25, 0x9b, + 0xc4, 0x22, 0x4a, 0x80, 0x0c, 0x70, 0x2d, 0x2f, 0x00, 0x25, 0xba, 0xdb, 0x75, 0xe9, 0x46, 0xfb, + 0xf4, 0xef, 0x59, 0x5a, 0x56, 0xe5, 0x3c, 0x79, 0x66, 0x76, 0x5a, 0x4a, 0xe8, 0x3e, 0x0d, 0x7c, + 0x4e, 0x8b, 0xc3, 0xd2, 0xb5, 0xe3, 0xe5, 0x2e, 0x3d, 0x06, 0x79, 0x3e, 0x03, 0xaf, 0xa0, 0x6a, + 0x63, 0xed, 0x7d, 0x5c, 0x53, 0x52, 0x85, 0xef, 0x95, 0x99, 0x86, 0x56, 0xee, 0x0c, 0x30, 0xf1, + 0x24, 0x9c, 0x06, 0x9f, 0xb6, 0x0d, 0xe4, 0x2e, 0xde, 0x89, 0xd5, 0x80, 0xce, 0x44, 0x57, 0x9d, + 0x17, 0xf8, 0xf6, 0x15, 0x21, 0x1d, 0x81, 0xce, 0x0f, 0x5d, 0xc9, 0xaf, 0xf4, 0x61, 0xad, 0xf9, + 0xe8, 0x2e, 0x11, 0x6e, 0xbc, 0xce, 0x40, 0xce, 0x47, 0x20, 0xf3, 0x80, 0x03, 0xe1, 0xb8, 0x6e, + 0x32, 0x21, 0x0f, 0xb7, 0x0a, 0x4e, 0x59, 0x6f, 0x3f, 0xba, 0x46, 0xc8, 0x24, 0xc2, 0xbb, 0x6b, + 0xa6, 0xc9, 0xe3, 0xff, 0xcc, 0xfe, 0x9b, 0x52, 0x9b, 0x6e, 0x4b, 0x2f, 0xb7, 0x3d, 0x41, 0xfd, + 0x0b, 0xeb, 0xdb, 0xc2, 0x46, 0x97, 0x0b, 0x1b, 0xfd, 0x5c, 0xd8, 0xe8, 0xf3, 0xd2, 0xae, 0x5c, + 0x2e, 0xed, 0xca, 0x8f, 0xa5, 0x5d, 0xc1, 0xfb, 0x5c, 0x84, 0x9b, 0xf5, 0xfa, 0x8d, 0x51, 0x89, + 0x78, 0xc5, 0x3f, 0xec, 0xa1, 0xf7, 0x6f, 0xcf, 0x82, 0x74, 0x9a, 0xf9, 0xc5, 0xfd, 0x3b, 0x5c, + 0x24, 0xa1, 0x48, 0x1c, 0x09, 0x33, 0x36, 0x07, 0xe9, 0xe4, 0xdd, 0x3f, 0x9f, 0xea, 0xd2, 0x12, + 0x67, 0xe3, 0xf3, 0x7a, 0xae, 0x01, 0x53, 0x5f, 0x58, 0x55, 0x6f, 0xf4, 0xee, 0x8b, 0xd5, 0xf2, + 0x8c, 0x11, 0xbd, 0x96, 0x9e, 0x68, 0xc6, 0xf7, 0x55, 0x6f, 0xac, 0x7b, 0x63, 0xd3, 0x5b, 0x58, + 0x0f, 0x36, 0xf6, 0xc6, 0x03, 0xaf, 0x7f, 0x0c, 0x29, 0x9b, 0xb0, 0x94, 0xfd, 0xb2, 0xee, 0x19, + 0x5e, 0xaf, 0xa7, 0x89, 0xbd, 0x9e, 0x61, 0xfa, 0x3b, 0xea, 0x9d, 0x3e, 0xfd, 0x1d, 0x00, 0x00, + 0xff, 0xff, 0x38, 0xfe, 0xb9, 0xc0, 0x16, 0x04, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryServiceClient is the client API for QueryService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryServiceClient interface { + // General-purpose key-value state query API, that can be used to query + // arbitrary keys in the JMT storage. + KeyValue(ctx context.Context, in *KeyValueRequest, opts ...grpc.CallOption) (*KeyValueResponse, error) + // General-purpose prefixed key-value state query API, that can be used to query + // arbitrary prefixes in the JMT storage. + // Returns a stream of `PrefixValueResponse`s. + PrefixValue(ctx context.Context, in *PrefixValueRequest, opts ...grpc.CallOption) (QueryService_PrefixValueClient, error) +} + +type queryServiceClient struct { + cc grpc1.ClientConn +} + +func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient { + return &queryServiceClient{cc} +} + +func (c *queryServiceClient) KeyValue(ctx context.Context, in *KeyValueRequest, opts ...grpc.CallOption) (*KeyValueResponse, error) { + out := new(KeyValueResponse) + err := c.cc.Invoke(ctx, "/penumbra.storage.v1alpha1.QueryService/KeyValue", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryServiceClient) PrefixValue(ctx context.Context, in *PrefixValueRequest, opts ...grpc.CallOption) (QueryService_PrefixValueClient, error) { + stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.storage.v1alpha1.QueryService/PrefixValue", opts...) + if err != nil { + return nil, err + } + x := &queryServicePrefixValueClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type QueryService_PrefixValueClient interface { + Recv() (*PrefixValueResponse, error) + grpc.ClientStream +} + +type queryServicePrefixValueClient struct { + grpc.ClientStream +} + +func (x *queryServicePrefixValueClient) Recv() (*PrefixValueResponse, error) { + m := new(PrefixValueResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// QueryServiceServer is the server API for QueryService service. +type QueryServiceServer interface { + // General-purpose key-value state query API, that can be used to query + // arbitrary keys in the JMT storage. + KeyValue(context.Context, *KeyValueRequest) (*KeyValueResponse, error) + // General-purpose prefixed key-value state query API, that can be used to query + // arbitrary prefixes in the JMT storage. + // Returns a stream of `PrefixValueResponse`s. + PrefixValue(*PrefixValueRequest, QueryService_PrefixValueServer) error +} + +// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServiceServer struct { +} + +func (*UnimplementedQueryServiceServer) KeyValue(ctx context.Context, req *KeyValueRequest) (*KeyValueResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method KeyValue not implemented") +} +func (*UnimplementedQueryServiceServer) PrefixValue(req *PrefixValueRequest, srv QueryService_PrefixValueServer) error { + return status.Errorf(codes.Unimplemented, "method PrefixValue not implemented") +} + +func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) { + s.RegisterService(&_QueryService_serviceDesc, srv) +} + +func _QueryService_KeyValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(KeyValueRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServiceServer).KeyValue(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.storage.v1alpha1.QueryService/KeyValue", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServiceServer).KeyValue(ctx, req.(*KeyValueRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueryService_PrefixValue_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(PrefixValueRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(QueryServiceServer).PrefixValue(m, &queryServicePrefixValueServer{stream}) +} + +type QueryService_PrefixValueServer interface { + Send(*PrefixValueResponse) error + grpc.ServerStream +} + +type queryServicePrefixValueServer struct { + grpc.ServerStream +} + +func (x *queryServicePrefixValueServer) Send(m *PrefixValueResponse) error { + return x.ServerStream.SendMsg(m) +} + +var _QueryService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.storage.v1alpha1.QueryService", + HandlerType: (*QueryServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "KeyValue", + Handler: _QueryService_KeyValue_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "PrefixValue", + Handler: _QueryService_PrefixValue_Handler, + ServerStreams: true, + }, + }, + Metadata: "penumbra/storage/v1alpha1/storage.proto", +} + +func (m *KeyValueRequest) 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 *KeyValueRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KeyValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Proof { + i-- + if m.Proof { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintStorage(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *KeyValueResponse) 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 *KeyValueResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KeyValueResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Proof != nil { + { + size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStorage(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *KeyValueResponse_Value) 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 *KeyValueResponse_Value) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KeyValueResponse_Value) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PrefixValueRequest) 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 *PrefixValueRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PrefixValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Prefix) > 0 { + i -= len(m.Prefix) + copy(dAtA[i:], m.Prefix) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Prefix))) + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintStorage(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PrefixValueResponse) 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 *PrefixValueResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PrefixValueResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintStorage(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintStorage(dAtA []byte, offset int, v uint64) int { + offset -= sovStorage(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *KeyValueRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + if m.Proof { + n += 2 + } + return n +} + +func (m *KeyValueResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovStorage(uint64(l)) + } + if m.Proof != nil { + l = m.Proof.Size() + n += 1 + l + sovStorage(uint64(l)) + } + return n +} + +func (m *KeyValueResponse_Value) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + return n +} + +func (m *PrefixValueRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + l = len(m.Prefix) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + return n +} + +func (m *PrefixValueResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovStorage(uint64(l)) + } + return n +} + +func sovStorage(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozStorage(x uint64) (n int) { + return sovStorage(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *KeyValueRequest) 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 ErrIntOverflowStorage + } + 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: KeyValueRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KeyValueRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Proof = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *KeyValueResponse) 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 ErrIntOverflowStorage + } + 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: KeyValueResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: KeyValueResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &KeyValueResponse_Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proof == nil { + m.Proof = &types.MerkleProof{} + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *KeyValueResponse_Value) 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 ErrIntOverflowStorage + } + 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: Value: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Value: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrefixValueRequest) 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 ErrIntOverflowStorage + } + 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: PrefixValueRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrefixValueRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Prefix = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrefixValueResponse) 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 ErrIntOverflowStorage + } + 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: PrefixValueResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrefixValueResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + 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 ErrInvalidLengthStorage + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStorage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStorage + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStorage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStorage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthStorage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipStorage(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, ErrIntOverflowStorage + } + 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, ErrIntOverflowStorage + } + 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, ErrIntOverflowStorage + } + 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, ErrInvalidLengthStorage + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupStorage + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthStorage + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthStorage = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowStorage = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupStorage = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/tools/summoning/v1alpha1/summoning.pb.go b/relayer/chains/penumbra/tools/summoning/v1alpha1/summoning.pb.go new file mode 100644 index 000000000..4b53bb93e --- /dev/null +++ b/relayer/chains/penumbra/tools/summoning/v1alpha1/summoning.pb.go @@ -0,0 +1,3694 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/tools/summoning/v1alpha1/summoning.proto + +package summoningv1alpha1 + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +type ParticipateRequest struct { + // Types that are valid to be assigned to Msg: + // *ParticipateRequest_Identify_ + // *ParticipateRequest_Contribution_ + Msg isParticipateRequest_Msg `protobuf_oneof:"msg"` +} + +func (m *ParticipateRequest) Reset() { *m = ParticipateRequest{} } +func (m *ParticipateRequest) String() string { return proto.CompactTextString(m) } +func (*ParticipateRequest) ProtoMessage() {} +func (*ParticipateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{0} +} +func (m *ParticipateRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ParticipateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ParticipateRequest.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 *ParticipateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ParticipateRequest.Merge(m, src) +} +func (m *ParticipateRequest) XXX_Size() int { + return m.Size() +} +func (m *ParticipateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ParticipateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ParticipateRequest proto.InternalMessageInfo + +type isParticipateRequest_Msg interface { + isParticipateRequest_Msg() + MarshalTo([]byte) (int, error) + Size() int +} + +type ParticipateRequest_Identify_ struct { + Identify *ParticipateRequest_Identify `protobuf:"bytes,1,opt,name=identify,proto3,oneof" json:"identify,omitempty"` +} +type ParticipateRequest_Contribution_ struct { + Contribution *ParticipateRequest_Contribution `protobuf:"bytes,2,opt,name=contribution,proto3,oneof" json:"contribution,omitempty"` +} + +func (*ParticipateRequest_Identify_) isParticipateRequest_Msg() {} +func (*ParticipateRequest_Contribution_) isParticipateRequest_Msg() {} + +func (m *ParticipateRequest) GetMsg() isParticipateRequest_Msg { + if m != nil { + return m.Msg + } + return nil +} + +func (m *ParticipateRequest) GetIdentify() *ParticipateRequest_Identify { + if x, ok := m.GetMsg().(*ParticipateRequest_Identify_); ok { + return x.Identify + } + return nil +} + +func (m *ParticipateRequest) GetContribution() *ParticipateRequest_Contribution { + if x, ok := m.GetMsg().(*ParticipateRequest_Contribution_); ok { + return x.Contribution + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ParticipateRequest) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ParticipateRequest_Identify_)(nil), + (*ParticipateRequest_Contribution_)(nil), + } +} + +// Sent at the beginning of the connection to identify the participant. +type ParticipateRequest_Identify struct { + Address *v1alpha1.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *ParticipateRequest_Identify) Reset() { *m = ParticipateRequest_Identify{} } +func (m *ParticipateRequest_Identify) String() string { return proto.CompactTextString(m) } +func (*ParticipateRequest_Identify) ProtoMessage() {} +func (*ParticipateRequest_Identify) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{0, 0} +} +func (m *ParticipateRequest_Identify) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ParticipateRequest_Identify) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ParticipateRequest_Identify.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 *ParticipateRequest_Identify) XXX_Merge(src proto.Message) { + xxx_messageInfo_ParticipateRequest_Identify.Merge(m, src) +} +func (m *ParticipateRequest_Identify) XXX_Size() int { + return m.Size() +} +func (m *ParticipateRequest_Identify) XXX_DiscardUnknown() { + xxx_messageInfo_ParticipateRequest_Identify.DiscardUnknown(m) +} + +var xxx_messageInfo_ParticipateRequest_Identify proto.InternalMessageInfo + +func (m *ParticipateRequest_Identify) GetAddress() *v1alpha1.Address { + if m != nil { + return m.Address + } + return nil +} + +// Sent by the participant after getting a `ContributeNow` message. +type ParticipateRequest_Contribution struct { + Updated *CeremonyCrs `protobuf:"bytes,1,opt,name=updated,proto3" json:"updated,omitempty"` + UpdateProofs *CeremonyLinkingProof `protobuf:"bytes,2,opt,name=update_proofs,json=updateProofs,proto3" json:"update_proofs,omitempty"` + ParentHashes *CeremonyParentHashes `protobuf:"bytes,3,opt,name=parent_hashes,json=parentHashes,proto3" json:"parent_hashes,omitempty"` +} + +func (m *ParticipateRequest_Contribution) Reset() { *m = ParticipateRequest_Contribution{} } +func (m *ParticipateRequest_Contribution) String() string { return proto.CompactTextString(m) } +func (*ParticipateRequest_Contribution) ProtoMessage() {} +func (*ParticipateRequest_Contribution) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{0, 1} +} +func (m *ParticipateRequest_Contribution) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ParticipateRequest_Contribution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ParticipateRequest_Contribution.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 *ParticipateRequest_Contribution) XXX_Merge(src proto.Message) { + xxx_messageInfo_ParticipateRequest_Contribution.Merge(m, src) +} +func (m *ParticipateRequest_Contribution) XXX_Size() int { + return m.Size() +} +func (m *ParticipateRequest_Contribution) XXX_DiscardUnknown() { + xxx_messageInfo_ParticipateRequest_Contribution.DiscardUnknown(m) +} + +var xxx_messageInfo_ParticipateRequest_Contribution proto.InternalMessageInfo + +func (m *ParticipateRequest_Contribution) GetUpdated() *CeremonyCrs { + if m != nil { + return m.Updated + } + return nil +} + +func (m *ParticipateRequest_Contribution) GetUpdateProofs() *CeremonyLinkingProof { + if m != nil { + return m.UpdateProofs + } + return nil +} + +func (m *ParticipateRequest_Contribution) GetParentHashes() *CeremonyParentHashes { + if m != nil { + return m.ParentHashes + } + return nil +} + +type CeremonyCrs struct { + Spend []byte `protobuf:"bytes,100,opt,name=spend,proto3" json:"spend,omitempty"` + Output []byte `protobuf:"bytes,101,opt,name=output,proto3" json:"output,omitempty"` + DelegatorVote []byte `protobuf:"bytes,102,opt,name=delegator_vote,json=delegatorVote,proto3" json:"delegator_vote,omitempty"` + UndelegateClaim []byte `protobuf:"bytes,103,opt,name=undelegate_claim,json=undelegateClaim,proto3" json:"undelegate_claim,omitempty"` + Swap []byte `protobuf:"bytes,104,opt,name=swap,proto3" json:"swap,omitempty"` + SwapClaim []byte `protobuf:"bytes,105,opt,name=swap_claim,json=swapClaim,proto3" json:"swap_claim,omitempty"` + NulliferDerivationCrs []byte `protobuf:"bytes,106,opt,name=nullifer_derivation_crs,json=nulliferDerivationCrs,proto3" json:"nullifer_derivation_crs,omitempty"` +} + +func (m *CeremonyCrs) Reset() { *m = CeremonyCrs{} } +func (m *CeremonyCrs) String() string { return proto.CompactTextString(m) } +func (*CeremonyCrs) ProtoMessage() {} +func (*CeremonyCrs) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{1} +} +func (m *CeremonyCrs) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CeremonyCrs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CeremonyCrs.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 *CeremonyCrs) XXX_Merge(src proto.Message) { + xxx_messageInfo_CeremonyCrs.Merge(m, src) +} +func (m *CeremonyCrs) XXX_Size() int { + return m.Size() +} +func (m *CeremonyCrs) XXX_DiscardUnknown() { + xxx_messageInfo_CeremonyCrs.DiscardUnknown(m) +} + +var xxx_messageInfo_CeremonyCrs proto.InternalMessageInfo + +func (m *CeremonyCrs) GetSpend() []byte { + if m != nil { + return m.Spend + } + return nil +} + +func (m *CeremonyCrs) GetOutput() []byte { + if m != nil { + return m.Output + } + return nil +} + +func (m *CeremonyCrs) GetDelegatorVote() []byte { + if m != nil { + return m.DelegatorVote + } + return nil +} + +func (m *CeremonyCrs) GetUndelegateClaim() []byte { + if m != nil { + return m.UndelegateClaim + } + return nil +} + +func (m *CeremonyCrs) GetSwap() []byte { + if m != nil { + return m.Swap + } + return nil +} + +func (m *CeremonyCrs) GetSwapClaim() []byte { + if m != nil { + return m.SwapClaim + } + return nil +} + +func (m *CeremonyCrs) GetNulliferDerivationCrs() []byte { + if m != nil { + return m.NulliferDerivationCrs + } + return nil +} + +type CeremonyLinkingProof struct { + Spend []byte `protobuf:"bytes,100,opt,name=spend,proto3" json:"spend,omitempty"` + Output []byte `protobuf:"bytes,101,opt,name=output,proto3" json:"output,omitempty"` + DelegatorVote []byte `protobuf:"bytes,102,opt,name=delegator_vote,json=delegatorVote,proto3" json:"delegator_vote,omitempty"` + UndelegateClaim []byte `protobuf:"bytes,103,opt,name=undelegate_claim,json=undelegateClaim,proto3" json:"undelegate_claim,omitempty"` + Swap []byte `protobuf:"bytes,104,opt,name=swap,proto3" json:"swap,omitempty"` + SwapClaim []byte `protobuf:"bytes,105,opt,name=swap_claim,json=swapClaim,proto3" json:"swap_claim,omitempty"` + NulliferDerivationCrs []byte `protobuf:"bytes,106,opt,name=nullifer_derivation_crs,json=nulliferDerivationCrs,proto3" json:"nullifer_derivation_crs,omitempty"` +} + +func (m *CeremonyLinkingProof) Reset() { *m = CeremonyLinkingProof{} } +func (m *CeremonyLinkingProof) String() string { return proto.CompactTextString(m) } +func (*CeremonyLinkingProof) ProtoMessage() {} +func (*CeremonyLinkingProof) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{2} +} +func (m *CeremonyLinkingProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CeremonyLinkingProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CeremonyLinkingProof.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 *CeremonyLinkingProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_CeremonyLinkingProof.Merge(m, src) +} +func (m *CeremonyLinkingProof) XXX_Size() int { + return m.Size() +} +func (m *CeremonyLinkingProof) XXX_DiscardUnknown() { + xxx_messageInfo_CeremonyLinkingProof.DiscardUnknown(m) +} + +var xxx_messageInfo_CeremonyLinkingProof proto.InternalMessageInfo + +func (m *CeremonyLinkingProof) GetSpend() []byte { + if m != nil { + return m.Spend + } + return nil +} + +func (m *CeremonyLinkingProof) GetOutput() []byte { + if m != nil { + return m.Output + } + return nil +} + +func (m *CeremonyLinkingProof) GetDelegatorVote() []byte { + if m != nil { + return m.DelegatorVote + } + return nil +} + +func (m *CeremonyLinkingProof) GetUndelegateClaim() []byte { + if m != nil { + return m.UndelegateClaim + } + return nil +} + +func (m *CeremonyLinkingProof) GetSwap() []byte { + if m != nil { + return m.Swap + } + return nil +} + +func (m *CeremonyLinkingProof) GetSwapClaim() []byte { + if m != nil { + return m.SwapClaim + } + return nil +} + +func (m *CeremonyLinkingProof) GetNulliferDerivationCrs() []byte { + if m != nil { + return m.NulliferDerivationCrs + } + return nil +} + +type CeremonyParentHashes struct { + Spend []byte `protobuf:"bytes,100,opt,name=spend,proto3" json:"spend,omitempty"` + Output []byte `protobuf:"bytes,101,opt,name=output,proto3" json:"output,omitempty"` + DelegatorVote []byte `protobuf:"bytes,102,opt,name=delegator_vote,json=delegatorVote,proto3" json:"delegator_vote,omitempty"` + UndelegateClaim []byte `protobuf:"bytes,103,opt,name=undelegate_claim,json=undelegateClaim,proto3" json:"undelegate_claim,omitempty"` + Swap []byte `protobuf:"bytes,104,opt,name=swap,proto3" json:"swap,omitempty"` + SwapClaim []byte `protobuf:"bytes,105,opt,name=swap_claim,json=swapClaim,proto3" json:"swap_claim,omitempty"` + NulliferDerivationCrs []byte `protobuf:"bytes,106,opt,name=nullifer_derivation_crs,json=nulliferDerivationCrs,proto3" json:"nullifer_derivation_crs,omitempty"` +} + +func (m *CeremonyParentHashes) Reset() { *m = CeremonyParentHashes{} } +func (m *CeremonyParentHashes) String() string { return proto.CompactTextString(m) } +func (*CeremonyParentHashes) ProtoMessage() {} +func (*CeremonyParentHashes) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{3} +} +func (m *CeremonyParentHashes) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CeremonyParentHashes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CeremonyParentHashes.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 *CeremonyParentHashes) XXX_Merge(src proto.Message) { + xxx_messageInfo_CeremonyParentHashes.Merge(m, src) +} +func (m *CeremonyParentHashes) XXX_Size() int { + return m.Size() +} +func (m *CeremonyParentHashes) XXX_DiscardUnknown() { + xxx_messageInfo_CeremonyParentHashes.DiscardUnknown(m) +} + +var xxx_messageInfo_CeremonyParentHashes proto.InternalMessageInfo + +func (m *CeremonyParentHashes) GetSpend() []byte { + if m != nil { + return m.Spend + } + return nil +} + +func (m *CeremonyParentHashes) GetOutput() []byte { + if m != nil { + return m.Output + } + return nil +} + +func (m *CeremonyParentHashes) GetDelegatorVote() []byte { + if m != nil { + return m.DelegatorVote + } + return nil +} + +func (m *CeremonyParentHashes) GetUndelegateClaim() []byte { + if m != nil { + return m.UndelegateClaim + } + return nil +} + +func (m *CeremonyParentHashes) GetSwap() []byte { + if m != nil { + return m.Swap + } + return nil +} + +func (m *CeremonyParentHashes) GetSwapClaim() []byte { + if m != nil { + return m.SwapClaim + } + return nil +} + +func (m *CeremonyParentHashes) GetNulliferDerivationCrs() []byte { + if m != nil { + return m.NulliferDerivationCrs + } + return nil +} + +type ParticipateResponse struct { + // Types that are valid to be assigned to Msg: + // + // *ParticipateResponse_Position_ + // *ParticipateResponse_ContributeNow_ + // *ParticipateResponse_Confirm_ + Msg isParticipateResponse_Msg `protobuf_oneof:"msg"` +} + +func (m *ParticipateResponse) Reset() { *m = ParticipateResponse{} } +func (m *ParticipateResponse) String() string { return proto.CompactTextString(m) } +func (*ParticipateResponse) ProtoMessage() {} +func (*ParticipateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{4} +} +func (m *ParticipateResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ParticipateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ParticipateResponse.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 *ParticipateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ParticipateResponse.Merge(m, src) +} +func (m *ParticipateResponse) XXX_Size() int { + return m.Size() +} +func (m *ParticipateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ParticipateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ParticipateResponse proto.InternalMessageInfo + +type isParticipateResponse_Msg interface { + isParticipateResponse_Msg() + MarshalTo([]byte) (int, error) + Size() int +} + +type ParticipateResponse_Position_ struct { + Position *ParticipateResponse_Position `protobuf:"bytes,1,opt,name=position,proto3,oneof" json:"position,omitempty"` +} +type ParticipateResponse_ContributeNow_ struct { + ContributeNow *ParticipateResponse_ContributeNow `protobuf:"bytes,2,opt,name=contribute_now,json=contributeNow,proto3,oneof" json:"contribute_now,omitempty"` +} +type ParticipateResponse_Confirm_ struct { + Confirm *ParticipateResponse_Confirm `protobuf:"bytes,3,opt,name=confirm,proto3,oneof" json:"confirm,omitempty"` +} + +func (*ParticipateResponse_Position_) isParticipateResponse_Msg() {} +func (*ParticipateResponse_ContributeNow_) isParticipateResponse_Msg() {} +func (*ParticipateResponse_Confirm_) isParticipateResponse_Msg() {} + +func (m *ParticipateResponse) GetMsg() isParticipateResponse_Msg { + if m != nil { + return m.Msg + } + return nil +} + +func (m *ParticipateResponse) GetPosition() *ParticipateResponse_Position { + if x, ok := m.GetMsg().(*ParticipateResponse_Position_); ok { + return x.Position + } + return nil +} + +func (m *ParticipateResponse) GetContributeNow() *ParticipateResponse_ContributeNow { + if x, ok := m.GetMsg().(*ParticipateResponse_ContributeNow_); ok { + return x.ContributeNow + } + return nil +} + +func (m *ParticipateResponse) GetConfirm() *ParticipateResponse_Confirm { + if x, ok := m.GetMsg().(*ParticipateResponse_Confirm_); ok { + return x.Confirm + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ParticipateResponse) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ParticipateResponse_Position_)(nil), + (*ParticipateResponse_ContributeNow_)(nil), + (*ParticipateResponse_Confirm_)(nil), + } +} + +// Streamed to the participant to inform them of their position in the queue. +type ParticipateResponse_Position struct { + // The position of the participant in the queue. + Position uint32 `protobuf:"varint,1,opt,name=position,proto3" json:"position,omitempty"` + // The total number of participants in the queue. + ConnectedParticipants uint32 `protobuf:"varint,2,opt,name=connected_participants,json=connectedParticipants,proto3" json:"connected_participants,omitempty"` + // The bid for the most recently executed contribution slot. + LastSlotBid *v1alpha11.Amount `protobuf:"bytes,3,opt,name=last_slot_bid,json=lastSlotBid,proto3" json:"last_slot_bid,omitempty"` + // The participant's current bid. + YourBid *v1alpha11.Amount `protobuf:"bytes,4,opt,name=your_bid,json=yourBid,proto3" json:"your_bid,omitempty"` +} + +func (m *ParticipateResponse_Position) Reset() { *m = ParticipateResponse_Position{} } +func (m *ParticipateResponse_Position) String() string { return proto.CompactTextString(m) } +func (*ParticipateResponse_Position) ProtoMessage() {} +func (*ParticipateResponse_Position) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{4, 0} +} +func (m *ParticipateResponse_Position) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ParticipateResponse_Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ParticipateResponse_Position.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 *ParticipateResponse_Position) XXX_Merge(src proto.Message) { + xxx_messageInfo_ParticipateResponse_Position.Merge(m, src) +} +func (m *ParticipateResponse_Position) XXX_Size() int { + return m.Size() +} +func (m *ParticipateResponse_Position) XXX_DiscardUnknown() { + xxx_messageInfo_ParticipateResponse_Position.DiscardUnknown(m) +} + +var xxx_messageInfo_ParticipateResponse_Position proto.InternalMessageInfo + +func (m *ParticipateResponse_Position) GetPosition() uint32 { + if m != nil { + return m.Position + } + return 0 +} + +func (m *ParticipateResponse_Position) GetConnectedParticipants() uint32 { + if m != nil { + return m.ConnectedParticipants + } + return 0 +} + +func (m *ParticipateResponse_Position) GetLastSlotBid() *v1alpha11.Amount { + if m != nil { + return m.LastSlotBid + } + return nil +} + +func (m *ParticipateResponse_Position) GetYourBid() *v1alpha11.Amount { + if m != nil { + return m.YourBid + } + return nil +} + +// Sent to the participant to inform them that they should contribute now. +type ParticipateResponse_ContributeNow struct { + // The most recent CRS, which the participant should update. + Parent *CeremonyCrs `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"` +} + +func (m *ParticipateResponse_ContributeNow) Reset() { *m = ParticipateResponse_ContributeNow{} } +func (m *ParticipateResponse_ContributeNow) String() string { return proto.CompactTextString(m) } +func (*ParticipateResponse_ContributeNow) ProtoMessage() {} +func (*ParticipateResponse_ContributeNow) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{4, 1} +} +func (m *ParticipateResponse_ContributeNow) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ParticipateResponse_ContributeNow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ParticipateResponse_ContributeNow.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 *ParticipateResponse_ContributeNow) XXX_Merge(src proto.Message) { + xxx_messageInfo_ParticipateResponse_ContributeNow.Merge(m, src) +} +func (m *ParticipateResponse_ContributeNow) XXX_Size() int { + return m.Size() +} +func (m *ParticipateResponse_ContributeNow) XXX_DiscardUnknown() { + xxx_messageInfo_ParticipateResponse_ContributeNow.DiscardUnknown(m) +} + +var xxx_messageInfo_ParticipateResponse_ContributeNow proto.InternalMessageInfo + +func (m *ParticipateResponse_ContributeNow) GetParent() *CeremonyCrs { + if m != nil { + return m.Parent + } + return nil +} + +// Sent to the participant to confim their contribution was accepted. +type ParticipateResponse_Confirm struct { + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` +} + +func (m *ParticipateResponse_Confirm) Reset() { *m = ParticipateResponse_Confirm{} } +func (m *ParticipateResponse_Confirm) String() string { return proto.CompactTextString(m) } +func (*ParticipateResponse_Confirm) ProtoMessage() {} +func (*ParticipateResponse_Confirm) Descriptor() ([]byte, []int) { + return fileDescriptor_b708086e6eced707, []int{4, 2} +} +func (m *ParticipateResponse_Confirm) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ParticipateResponse_Confirm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ParticipateResponse_Confirm.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 *ParticipateResponse_Confirm) XXX_Merge(src proto.Message) { + xxx_messageInfo_ParticipateResponse_Confirm.Merge(m, src) +} +func (m *ParticipateResponse_Confirm) XXX_Size() int { + return m.Size() +} +func (m *ParticipateResponse_Confirm) XXX_DiscardUnknown() { + xxx_messageInfo_ParticipateResponse_Confirm.DiscardUnknown(m) +} + +var xxx_messageInfo_ParticipateResponse_Confirm proto.InternalMessageInfo + +func (m *ParticipateResponse_Confirm) GetSlot() uint64 { + if m != nil { + return m.Slot + } + return 0 +} + +func init() { + proto.RegisterType((*ParticipateRequest)(nil), "penumbra.tools.summoning.v1alpha1.ParticipateRequest") + proto.RegisterType((*ParticipateRequest_Identify)(nil), "penumbra.tools.summoning.v1alpha1.ParticipateRequest.Identify") + proto.RegisterType((*ParticipateRequest_Contribution)(nil), "penumbra.tools.summoning.v1alpha1.ParticipateRequest.Contribution") + proto.RegisterType((*CeremonyCrs)(nil), "penumbra.tools.summoning.v1alpha1.CeremonyCrs") + proto.RegisterType((*CeremonyLinkingProof)(nil), "penumbra.tools.summoning.v1alpha1.CeremonyLinkingProof") + proto.RegisterType((*CeremonyParentHashes)(nil), "penumbra.tools.summoning.v1alpha1.CeremonyParentHashes") + proto.RegisterType((*ParticipateResponse)(nil), "penumbra.tools.summoning.v1alpha1.ParticipateResponse") + proto.RegisterType((*ParticipateResponse_Position)(nil), "penumbra.tools.summoning.v1alpha1.ParticipateResponse.Position") + proto.RegisterType((*ParticipateResponse_ContributeNow)(nil), "penumbra.tools.summoning.v1alpha1.ParticipateResponse.ContributeNow") + proto.RegisterType((*ParticipateResponse_Confirm)(nil), "penumbra.tools.summoning.v1alpha1.ParticipateResponse.Confirm") +} + +func init() { + proto.RegisterFile("penumbra/tools/summoning/v1alpha1/summoning.proto", fileDescriptor_b708086e6eced707) +} + +var fileDescriptor_b708086e6eced707 = []byte{ + // 899 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0xcf, 0x8f, 0xdb, 0x44, + 0x14, 0x8e, 0xb3, 0x3f, 0x12, 0xde, 0x26, 0x0b, 0x1a, 0xda, 0x62, 0x59, 0x6a, 0xd4, 0xae, 0xb6, + 0x68, 0x39, 0xe0, 0xb0, 0x8b, 0x5a, 0xa4, 0x20, 0x16, 0x91, 0x54, 0x25, 0x20, 0x40, 0x96, 0xb7, + 0x2a, 0x52, 0x15, 0x64, 0x4d, 0xec, 0x49, 0x32, 0xd4, 0x9e, 0x31, 0x33, 0xe3, 0xac, 0x72, 0x83, + 0xff, 0x80, 0x03, 0x77, 0x24, 0x24, 0x2e, 0xfc, 0x21, 0x08, 0x71, 0xea, 0x0d, 0x8e, 0x68, 0x97, + 0x13, 0x7f, 0x01, 0x47, 0xe4, 0xf1, 0xcf, 0x2d, 0x95, 0xb6, 0x9b, 0x6b, 0x4f, 0x99, 0x79, 0xef, + 0xfb, 0xbe, 0x37, 0xef, 0xd9, 0xf9, 0xc6, 0x70, 0x18, 0x13, 0x96, 0x44, 0x53, 0x81, 0xfb, 0x8a, + 0xf3, 0x50, 0xf6, 0x65, 0x12, 0x45, 0x9c, 0x51, 0x36, 0xef, 0x2f, 0x0f, 0x71, 0x18, 0x2f, 0xf0, + 0x61, 0x15, 0xb2, 0x63, 0xc1, 0x15, 0x47, 0xb7, 0x0b, 0x8a, 0xad, 0x29, 0x76, 0x95, 0x2f, 0x28, + 0xd6, 0x9b, 0xa5, 0xaa, 0xcf, 0x05, 0xe9, 0x3f, 0x21, 0x2b, 0x59, 0xe9, 0xa5, 0xbb, 0x4c, 0xca, + 0xda, 0xbf, 0x88, 0x63, 0x49, 0x54, 0xc1, 0x58, 0x12, 0x65, 0xa8, 0xbd, 0x5f, 0x37, 0x01, 0x39, + 0x58, 0x28, 0xea, 0xd3, 0x18, 0x2b, 0xe2, 0x92, 0x6f, 0x12, 0x22, 0x15, 0x9a, 0x40, 0x9b, 0x06, + 0x84, 0x29, 0x3a, 0x5b, 0x99, 0xc6, 0x2d, 0xe3, 0x60, 0xe7, 0xe8, 0xd8, 0xbe, 0xf4, 0x68, 0xf6, + 0xff, 0x85, 0xec, 0x4f, 0x72, 0x95, 0x71, 0xc3, 0x2d, 0x15, 0xd1, 0x02, 0x3a, 0x3e, 0x67, 0x4a, + 0xd0, 0x69, 0xa2, 0x28, 0x67, 0x66, 0x53, 0x57, 0x18, 0xae, 0x57, 0x61, 0x54, 0x53, 0x1a, 0x37, + 0xdc, 0x0b, 0xca, 0xd6, 0xa7, 0xd0, 0x2e, 0x4e, 0x80, 0x8e, 0xa1, 0x85, 0x83, 0x40, 0x10, 0x29, + 0xf3, 0x96, 0xf6, 0xab, 0x82, 0xe9, 0x88, 0x6c, 0x3d, 0xbc, 0xb2, 0xd4, 0x47, 0x19, 0xd6, 0x2d, + 0x48, 0xd6, 0x0f, 0x4d, 0xe8, 0xd4, 0x8b, 0xa1, 0x31, 0xb4, 0x92, 0x38, 0xc0, 0x8a, 0x04, 0xb9, + 0xa0, 0xfd, 0x02, 0x1d, 0x8c, 0x88, 0x20, 0x11, 0x67, 0xab, 0x91, 0x90, 0x6e, 0x41, 0x47, 0x13, + 0xe8, 0x66, 0x4b, 0x2f, 0x16, 0x9c, 0xcf, 0x64, 0x3e, 0x91, 0xf7, 0xae, 0xa0, 0xf7, 0x19, 0x65, + 0x4f, 0x28, 0x9b, 0x3b, 0x29, 0xdf, 0xed, 0x64, 0x6a, 0x7a, 0x23, 0x53, 0xf5, 0x18, 0x0b, 0xc2, + 0x94, 0xb7, 0xc0, 0x72, 0x41, 0xa4, 0xb9, 0x71, 0x65, 0x75, 0x47, 0xf3, 0xc7, 0x9a, 0xee, 0x76, + 0xe2, 0xda, 0x6e, 0xb8, 0x05, 0x1b, 0x91, 0x9c, 0xef, 0xfd, 0x6b, 0xc0, 0x4e, 0xad, 0x37, 0x74, + 0x0d, 0xb6, 0x64, 0x4c, 0x58, 0x60, 0x06, 0xb7, 0x8c, 0x83, 0x8e, 0x9b, 0x6d, 0xd0, 0x0d, 0xd8, + 0xe6, 0x89, 0x8a, 0x13, 0x65, 0x12, 0x1d, 0xce, 0x77, 0xe8, 0x0e, 0xec, 0x06, 0x24, 0x24, 0x73, + 0xac, 0xb8, 0xf0, 0x96, 0x5c, 0x11, 0x73, 0xa6, 0xf3, 0xdd, 0x32, 0xfa, 0x88, 0x2b, 0x82, 0xde, + 0x82, 0xd7, 0x12, 0x96, 0x87, 0x88, 0xe7, 0x87, 0x98, 0x46, 0xe6, 0x5c, 0x03, 0x5f, 0xad, 0xe2, + 0xa3, 0x34, 0x8c, 0x10, 0x6c, 0xca, 0x53, 0x1c, 0x9b, 0x0b, 0x9d, 0xd6, 0x6b, 0x74, 0x13, 0x20, + 0xfd, 0xcd, 0x89, 0x54, 0x67, 0x5e, 0x49, 0x23, 0x19, 0xe5, 0x1e, 0xbc, 0xc1, 0x92, 0x30, 0xa4, + 0x33, 0x22, 0xbc, 0x80, 0x08, 0xba, 0xc4, 0xe9, 0x63, 0xf6, 0x7c, 0x21, 0xcd, 0xaf, 0x35, 0xf6, + 0x7a, 0x91, 0xbe, 0x5f, 0x66, 0x47, 0x42, 0xee, 0x7d, 0xd7, 0x84, 0x6b, 0xcf, 0x7b, 0x0c, 0x2f, + 0xeb, 0x0c, 0xea, 0x2f, 0xcb, 0xcb, 0x34, 0x83, 0x9f, 0xb7, 0xe0, 0xf5, 0x0b, 0x06, 0x25, 0x63, + 0xce, 0x24, 0x41, 0x5f, 0x41, 0x3b, 0xe6, 0x92, 0x6a, 0xab, 0xcb, 0x8c, 0xe2, 0xc3, 0xab, 0x5a, + 0x5d, 0xa6, 0x64, 0x3b, 0xb9, 0x4c, 0xea, 0xa6, 0x85, 0x24, 0x8a, 0x60, 0xb7, 0xf4, 0x3c, 0xe2, + 0x31, 0x7e, 0x9a, 0xbb, 0xc7, 0xfd, 0x35, 0x8b, 0x94, 0x1e, 0x47, 0xbe, 0xe0, 0xa7, 0xe3, 0x86, + 0xdb, 0xf5, 0xeb, 0x01, 0xf4, 0x18, 0x5a, 0x3e, 0x67, 0x33, 0x2a, 0xa2, 0xdc, 0x47, 0x8e, 0xd7, + 0xaf, 0x93, 0xaa, 0x8c, 0x1b, 0x6e, 0x21, 0x68, 0xfd, 0x6d, 0x40, 0xbb, 0xe8, 0x11, 0x59, 0xcf, + 0x8c, 0xad, 0x5b, 0xeb, 0xf9, 0x2e, 0xdc, 0xf0, 0x39, 0x63, 0xc4, 0x57, 0x24, 0xf0, 0xe2, 0x42, + 0x9c, 0xa9, 0xcc, 0x39, 0xbb, 0xee, 0xf5, 0x32, 0xeb, 0xd4, 0x92, 0xe8, 0x01, 0x74, 0x43, 0x2c, + 0x95, 0x27, 0x43, 0xae, 0xbc, 0x29, 0x0d, 0xf2, 0x0e, 0xf6, 0x9e, 0xb9, 0x08, 0xd2, 0xeb, 0xb1, + 0xba, 0x07, 0x22, 0x9e, 0x30, 0xe5, 0xee, 0xa4, 0xc4, 0x93, 0x90, 0xab, 0x21, 0x0d, 0xd0, 0x07, + 0xd0, 0x5e, 0xf1, 0x44, 0x68, 0x89, 0xcd, 0x17, 0x96, 0x68, 0xa5, 0x9c, 0x21, 0x0d, 0xac, 0x2f, + 0xa1, 0x7b, 0x61, 0xc8, 0xe8, 0x01, 0x6c, 0x67, 0x9e, 0xba, 0xe6, 0x45, 0x92, 0xb3, 0xad, 0x9b, + 0xd0, 0xca, 0xa7, 0xaa, 0xdf, 0xfb, 0x90, 0x67, 0x82, 0x9b, 0xae, 0x5e, 0xe7, 0x56, 0x7d, 0xf4, + 0xa3, 0x01, 0x56, 0xc9, 0xe6, 0x5c, 0x04, 0x94, 0xa5, 0xff, 0xac, 0x13, 0x22, 0x96, 0xd4, 0x27, + 0xe8, 0x5b, 0x03, 0x76, 0x6a, 0xcf, 0x0b, 0xdd, 0x5d, 0xeb, 0x5e, 0xb6, 0xee, 0xad, 0xf7, 0x5a, + 0x1c, 0x18, 0xef, 0x18, 0xc3, 0x3f, 0x9a, 0xbf, 0x9d, 0xf5, 0x8c, 0xa7, 0x67, 0x3d, 0xe3, 0xaf, + 0xb3, 0x9e, 0xf1, 0xfd, 0x79, 0xaf, 0xf1, 0xf4, 0xbc, 0xd7, 0xf8, 0xf3, 0xbc, 0xd7, 0x80, 0x3b, + 0x3e, 0x8f, 0x2e, 0x57, 0x1e, 0xee, 0x9e, 0x14, 0x31, 0x27, 0xfd, 0xce, 0x71, 0x8c, 0xc7, 0xde, + 0x9c, 0xaa, 0x45, 0x32, 0xb5, 0x7d, 0x1e, 0xf5, 0x7d, 0x2e, 0x23, 0x2e, 0xfb, 0x82, 0x84, 0x78, + 0x45, 0x44, 0x7f, 0x79, 0x54, 0x2e, 0xfd, 0x05, 0xa6, 0x4c, 0xf6, 0x2f, 0xfd, 0x72, 0x7b, 0xbf, + 0x0c, 0x15, 0x91, 0x9f, 0x9a, 0x1b, 0xce, 0xc3, 0x93, 0x5f, 0x9a, 0xb7, 0x9d, 0xe2, 0x70, 0x0f, + 0xf5, 0xe1, 0xca, 0x83, 0xd8, 0x8f, 0x72, 0xe4, 0xef, 0x15, 0x66, 0xa2, 0x31, 0x93, 0x12, 0x33, + 0x29, 0x30, 0x67, 0xcd, 0xb7, 0x2f, 0xc5, 0x4c, 0x3e, 0x76, 0x86, 0x9f, 0x13, 0x85, 0x03, 0xac, + 0xf0, 0x3f, 0xcd, 0xfd, 0x02, 0x3f, 0x18, 0x68, 0xc2, 0x60, 0x50, 0x32, 0x06, 0x83, 0x82, 0x32, + 0xdd, 0xd6, 0x9f, 0x7d, 0xef, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0x3a, 0xc3, 0x4c, 0x79, 0x9c, + 0x0a, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// CeremonyCoordinatorServiceClient is the client API for CeremonyCoordinatorService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type CeremonyCoordinatorServiceClient interface { + // The protocol used to participate in the ceremony. + // + // The message flow is + // ``` + // Client Server + // + // Identify ===========> + // <=========== Position (repeated) + // <=========== ContributeNow + // Contribution ===========> + // <=========== Confirm + // + // ``` + Participate(ctx context.Context, opts ...grpc.CallOption) (CeremonyCoordinatorService_ParticipateClient, error) +} + +type ceremonyCoordinatorServiceClient struct { + cc grpc1.ClientConn +} + +func NewCeremonyCoordinatorServiceClient(cc grpc1.ClientConn) CeremonyCoordinatorServiceClient { + return &ceremonyCoordinatorServiceClient{cc} +} + +func (c *ceremonyCoordinatorServiceClient) Participate(ctx context.Context, opts ...grpc.CallOption) (CeremonyCoordinatorService_ParticipateClient, error) { + stream, err := c.cc.NewStream(ctx, &_CeremonyCoordinatorService_serviceDesc.Streams[0], "/penumbra.tools.summoning.v1alpha1.CeremonyCoordinatorService/Participate", opts...) + if err != nil { + return nil, err + } + x := &ceremonyCoordinatorServiceParticipateClient{stream} + return x, nil +} + +type CeremonyCoordinatorService_ParticipateClient interface { + Send(*ParticipateRequest) error + Recv() (*ParticipateResponse, error) + grpc.ClientStream +} + +type ceremonyCoordinatorServiceParticipateClient struct { + grpc.ClientStream +} + +func (x *ceremonyCoordinatorServiceParticipateClient) Send(m *ParticipateRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *ceremonyCoordinatorServiceParticipateClient) Recv() (*ParticipateResponse, error) { + m := new(ParticipateResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// CeremonyCoordinatorServiceServer is the server API for CeremonyCoordinatorService service. +type CeremonyCoordinatorServiceServer interface { + // The protocol used to participate in the ceremony. + // + // The message flow is + // ``` + // Client Server + // + // Identify ===========> + // <=========== Position (repeated) + // <=========== ContributeNow + // Contribution ===========> + // <=========== Confirm + // + // ``` + Participate(CeremonyCoordinatorService_ParticipateServer) error +} + +// UnimplementedCeremonyCoordinatorServiceServer can be embedded to have forward compatible implementations. +type UnimplementedCeremonyCoordinatorServiceServer struct { +} + +func (*UnimplementedCeremonyCoordinatorServiceServer) Participate(srv CeremonyCoordinatorService_ParticipateServer) error { + return status.Errorf(codes.Unimplemented, "method Participate not implemented") +} + +func RegisterCeremonyCoordinatorServiceServer(s grpc1.Server, srv CeremonyCoordinatorServiceServer) { + s.RegisterService(&_CeremonyCoordinatorService_serviceDesc, srv) +} + +func _CeremonyCoordinatorService_Participate_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(CeremonyCoordinatorServiceServer).Participate(&ceremonyCoordinatorServiceParticipateServer{stream}) +} + +type CeremonyCoordinatorService_ParticipateServer interface { + Send(*ParticipateResponse) error + Recv() (*ParticipateRequest, error) + grpc.ServerStream +} + +type ceremonyCoordinatorServiceParticipateServer struct { + grpc.ServerStream +} + +func (x *ceremonyCoordinatorServiceParticipateServer) Send(m *ParticipateResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *ceremonyCoordinatorServiceParticipateServer) Recv() (*ParticipateRequest, error) { + m := new(ParticipateRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +var _CeremonyCoordinatorService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.tools.summoning.v1alpha1.CeremonyCoordinatorService", + HandlerType: (*CeremonyCoordinatorServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "Participate", + Handler: _CeremonyCoordinatorService_Participate_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "penumbra/tools/summoning/v1alpha1/summoning.proto", +} + +func (m *ParticipateRequest) 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 *ParticipateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Msg != nil { + { + size := m.Msg.Size() + i -= size + if _, err := m.Msg.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *ParticipateRequest_Identify_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateRequest_Identify_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Identify != nil { + { + size, err := m.Identify.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *ParticipateRequest_Contribution_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateRequest_Contribution_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Contribution != nil { + { + size, err := m.Contribution.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *ParticipateRequest_Identify) 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 *ParticipateRequest_Identify) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateRequest_Identify) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Address != nil { + { + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ParticipateRequest_Contribution) 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 *ParticipateRequest_Contribution) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateRequest_Contribution) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ParentHashes != nil { + { + size, err := m.ParentHashes.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.UpdateProofs != nil { + { + size, err := m.UpdateProofs.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Updated != nil { + { + size, err := m.Updated.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CeremonyCrs) 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 *CeremonyCrs) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CeremonyCrs) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.NulliferDerivationCrs) > 0 { + i -= len(m.NulliferDerivationCrs) + copy(dAtA[i:], m.NulliferDerivationCrs) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.NulliferDerivationCrs))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xd2 + } + if len(m.SwapClaim) > 0 { + i -= len(m.SwapClaim) + copy(dAtA[i:], m.SwapClaim) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.SwapClaim))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xca + } + if len(m.Swap) > 0 { + i -= len(m.Swap) + copy(dAtA[i:], m.Swap) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.Swap))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xc2 + } + if len(m.UndelegateClaim) > 0 { + i -= len(m.UndelegateClaim) + copy(dAtA[i:], m.UndelegateClaim) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.UndelegateClaim))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xba + } + if len(m.DelegatorVote) > 0 { + i -= len(m.DelegatorVote) + copy(dAtA[i:], m.DelegatorVote) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.DelegatorVote))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xb2 + } + if len(m.Output) > 0 { + i -= len(m.Output) + copy(dAtA[i:], m.Output) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.Output))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xaa + } + if len(m.Spend) > 0 { + i -= len(m.Spend) + copy(dAtA[i:], m.Spend) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.Spend))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} + +func (m *CeremonyLinkingProof) 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 *CeremonyLinkingProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CeremonyLinkingProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.NulliferDerivationCrs) > 0 { + i -= len(m.NulliferDerivationCrs) + copy(dAtA[i:], m.NulliferDerivationCrs) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.NulliferDerivationCrs))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xd2 + } + if len(m.SwapClaim) > 0 { + i -= len(m.SwapClaim) + copy(dAtA[i:], m.SwapClaim) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.SwapClaim))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xca + } + if len(m.Swap) > 0 { + i -= len(m.Swap) + copy(dAtA[i:], m.Swap) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.Swap))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xc2 + } + if len(m.UndelegateClaim) > 0 { + i -= len(m.UndelegateClaim) + copy(dAtA[i:], m.UndelegateClaim) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.UndelegateClaim))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xba + } + if len(m.DelegatorVote) > 0 { + i -= len(m.DelegatorVote) + copy(dAtA[i:], m.DelegatorVote) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.DelegatorVote))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xb2 + } + if len(m.Output) > 0 { + i -= len(m.Output) + copy(dAtA[i:], m.Output) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.Output))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xaa + } + if len(m.Spend) > 0 { + i -= len(m.Spend) + copy(dAtA[i:], m.Spend) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.Spend))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} + +func (m *CeremonyParentHashes) 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 *CeremonyParentHashes) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CeremonyParentHashes) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.NulliferDerivationCrs) > 0 { + i -= len(m.NulliferDerivationCrs) + copy(dAtA[i:], m.NulliferDerivationCrs) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.NulliferDerivationCrs))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xd2 + } + if len(m.SwapClaim) > 0 { + i -= len(m.SwapClaim) + copy(dAtA[i:], m.SwapClaim) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.SwapClaim))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xca + } + if len(m.Swap) > 0 { + i -= len(m.Swap) + copy(dAtA[i:], m.Swap) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.Swap))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xc2 + } + if len(m.UndelegateClaim) > 0 { + i -= len(m.UndelegateClaim) + copy(dAtA[i:], m.UndelegateClaim) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.UndelegateClaim))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xba + } + if len(m.DelegatorVote) > 0 { + i -= len(m.DelegatorVote) + copy(dAtA[i:], m.DelegatorVote) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.DelegatorVote))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xb2 + } + if len(m.Output) > 0 { + i -= len(m.Output) + copy(dAtA[i:], m.Output) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.Output))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xaa + } + if len(m.Spend) > 0 { + i -= len(m.Spend) + copy(dAtA[i:], m.Spend) + i = encodeVarintSummoning(dAtA, i, uint64(len(m.Spend))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} + +func (m *ParticipateResponse) 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 *ParticipateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Msg != nil { + { + size := m.Msg.Size() + i -= size + if _, err := m.Msg.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *ParticipateResponse_Position_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateResponse_Position_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Position != nil { + { + size, err := m.Position.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *ParticipateResponse_ContributeNow_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateResponse_ContributeNow_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ContributeNow != nil { + { + size, err := m.ContributeNow.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *ParticipateResponse_Confirm_) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateResponse_Confirm_) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Confirm != nil { + { + size, err := m.Confirm.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *ParticipateResponse_Position) 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 *ParticipateResponse_Position) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateResponse_Position) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.YourBid != nil { + { + size, err := m.YourBid.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.LastSlotBid != nil { + { + size, err := m.LastSlotBid.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.ConnectedParticipants != 0 { + i = encodeVarintSummoning(dAtA, i, uint64(m.ConnectedParticipants)) + i-- + dAtA[i] = 0x10 + } + if m.Position != 0 { + i = encodeVarintSummoning(dAtA, i, uint64(m.Position)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ParticipateResponse_ContributeNow) 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 *ParticipateResponse_ContributeNow) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateResponse_ContributeNow) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Parent != nil { + { + size, err := m.Parent.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSummoning(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ParticipateResponse_Confirm) 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 *ParticipateResponse_Confirm) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ParticipateResponse_Confirm) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Slot != 0 { + i = encodeVarintSummoning(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintSummoning(dAtA []byte, offset int, v uint64) int { + offset -= sovSummoning(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ParticipateRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Msg != nil { + n += m.Msg.Size() + } + return n +} + +func (m *ParticipateRequest_Identify_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Identify != nil { + l = m.Identify.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + return n +} +func (m *ParticipateRequest_Contribution_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Contribution != nil { + l = m.Contribution.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + return n +} +func (m *ParticipateRequest_Identify) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Address != nil { + l = m.Address.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + return n +} + +func (m *ParticipateRequest_Contribution) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Updated != nil { + l = m.Updated.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + if m.UpdateProofs != nil { + l = m.UpdateProofs.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + if m.ParentHashes != nil { + l = m.ParentHashes.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + return n +} + +func (m *CeremonyCrs) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Spend) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.Output) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.DelegatorVote) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.UndelegateClaim) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.Swap) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.SwapClaim) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.NulliferDerivationCrs) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + return n +} + +func (m *CeremonyLinkingProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Spend) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.Output) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.DelegatorVote) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.UndelegateClaim) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.Swap) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.SwapClaim) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.NulliferDerivationCrs) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + return n +} + +func (m *CeremonyParentHashes) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Spend) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.Output) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.DelegatorVote) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.UndelegateClaim) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.Swap) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.SwapClaim) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + l = len(m.NulliferDerivationCrs) + if l > 0 { + n += 2 + l + sovSummoning(uint64(l)) + } + return n +} + +func (m *ParticipateResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Msg != nil { + n += m.Msg.Size() + } + return n +} + +func (m *ParticipateResponse_Position_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Position != nil { + l = m.Position.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + return n +} +func (m *ParticipateResponse_ContributeNow_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ContributeNow != nil { + l = m.ContributeNow.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + return n +} +func (m *ParticipateResponse_Confirm_) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Confirm != nil { + l = m.Confirm.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + return n +} +func (m *ParticipateResponse_Position) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Position != 0 { + n += 1 + sovSummoning(uint64(m.Position)) + } + if m.ConnectedParticipants != 0 { + n += 1 + sovSummoning(uint64(m.ConnectedParticipants)) + } + if m.LastSlotBid != nil { + l = m.LastSlotBid.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + if m.YourBid != nil { + l = m.YourBid.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + return n +} + +func (m *ParticipateResponse_ContributeNow) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Parent != nil { + l = m.Parent.Size() + n += 1 + l + sovSummoning(uint64(l)) + } + return n +} + +func (m *ParticipateResponse_Confirm) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + sovSummoning(uint64(m.Slot)) + } + return n +} + +func sovSummoning(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozSummoning(x uint64) (n int) { + return sovSummoning(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ParticipateRequest) 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 ErrIntOverflowSummoning + } + 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: ParticipateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ParticipateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Identify", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ParticipateRequest_Identify{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Msg = &ParticipateRequest_Identify_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contribution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ParticipateRequest_Contribution{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Msg = &ParticipateRequest_Contribution_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ParticipateRequest_Identify) 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 ErrIntOverflowSummoning + } + 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: Identify: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Identify: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &v1alpha1.Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ParticipateRequest_Contribution) 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 ErrIntOverflowSummoning + } + 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: Contribution: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Contribution: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Updated", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Updated == nil { + m.Updated = &CeremonyCrs{} + } + if err := m.Updated.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdateProofs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.UpdateProofs == nil { + m.UpdateProofs = &CeremonyLinkingProof{} + } + if err := m.UpdateProofs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHashes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ParentHashes == nil { + m.ParentHashes = &CeremonyParentHashes{} + } + if err := m.ParentHashes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CeremonyCrs) 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 ErrIntOverflowSummoning + } + 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: CeremonyCrs: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CeremonyCrs: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 100: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Spend = append(m.Spend[:0], dAtA[iNdEx:postIndex]...) + if m.Spend == nil { + m.Spend = []byte{} + } + iNdEx = postIndex + case 101: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Output = append(m.Output[:0], dAtA[iNdEx:postIndex]...) + if m.Output == nil { + m.Output = []byte{} + } + iNdEx = postIndex + case 102: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorVote = append(m.DelegatorVote[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorVote == nil { + m.DelegatorVote = []byte{} + } + iNdEx = postIndex + case 103: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UndelegateClaim = append(m.UndelegateClaim[:0], dAtA[iNdEx:postIndex]...) + if m.UndelegateClaim == nil { + m.UndelegateClaim = []byte{} + } + iNdEx = postIndex + case 104: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Swap = append(m.Swap[:0], dAtA[iNdEx:postIndex]...) + if m.Swap == nil { + m.Swap = []byte{} + } + iNdEx = postIndex + case 105: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SwapClaim = append(m.SwapClaim[:0], dAtA[iNdEx:postIndex]...) + if m.SwapClaim == nil { + m.SwapClaim = []byte{} + } + iNdEx = postIndex + case 106: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NulliferDerivationCrs", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NulliferDerivationCrs = append(m.NulliferDerivationCrs[:0], dAtA[iNdEx:postIndex]...) + if m.NulliferDerivationCrs == nil { + m.NulliferDerivationCrs = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CeremonyLinkingProof) 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 ErrIntOverflowSummoning + } + 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: CeremonyLinkingProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CeremonyLinkingProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 100: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Spend = append(m.Spend[:0], dAtA[iNdEx:postIndex]...) + if m.Spend == nil { + m.Spend = []byte{} + } + iNdEx = postIndex + case 101: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Output = append(m.Output[:0], dAtA[iNdEx:postIndex]...) + if m.Output == nil { + m.Output = []byte{} + } + iNdEx = postIndex + case 102: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorVote = append(m.DelegatorVote[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorVote == nil { + m.DelegatorVote = []byte{} + } + iNdEx = postIndex + case 103: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UndelegateClaim = append(m.UndelegateClaim[:0], dAtA[iNdEx:postIndex]...) + if m.UndelegateClaim == nil { + m.UndelegateClaim = []byte{} + } + iNdEx = postIndex + case 104: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Swap = append(m.Swap[:0], dAtA[iNdEx:postIndex]...) + if m.Swap == nil { + m.Swap = []byte{} + } + iNdEx = postIndex + case 105: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SwapClaim = append(m.SwapClaim[:0], dAtA[iNdEx:postIndex]...) + if m.SwapClaim == nil { + m.SwapClaim = []byte{} + } + iNdEx = postIndex + case 106: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NulliferDerivationCrs", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NulliferDerivationCrs = append(m.NulliferDerivationCrs[:0], dAtA[iNdEx:postIndex]...) + if m.NulliferDerivationCrs == nil { + m.NulliferDerivationCrs = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CeremonyParentHashes) 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 ErrIntOverflowSummoning + } + 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: CeremonyParentHashes: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CeremonyParentHashes: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 100: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Spend = append(m.Spend[:0], dAtA[iNdEx:postIndex]...) + if m.Spend == nil { + m.Spend = []byte{} + } + iNdEx = postIndex + case 101: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Output = append(m.Output[:0], dAtA[iNdEx:postIndex]...) + if m.Output == nil { + m.Output = []byte{} + } + iNdEx = postIndex + case 102: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorVote = append(m.DelegatorVote[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorVote == nil { + m.DelegatorVote = []byte{} + } + iNdEx = postIndex + case 103: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UndelegateClaim = append(m.UndelegateClaim[:0], dAtA[iNdEx:postIndex]...) + if m.UndelegateClaim == nil { + m.UndelegateClaim = []byte{} + } + iNdEx = postIndex + case 104: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Swap = append(m.Swap[:0], dAtA[iNdEx:postIndex]...) + if m.Swap == nil { + m.Swap = []byte{} + } + iNdEx = postIndex + case 105: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SwapClaim = append(m.SwapClaim[:0], dAtA[iNdEx:postIndex]...) + if m.SwapClaim == nil { + m.SwapClaim = []byte{} + } + iNdEx = postIndex + case 106: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NulliferDerivationCrs", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NulliferDerivationCrs = append(m.NulliferDerivationCrs[:0], dAtA[iNdEx:postIndex]...) + if m.NulliferDerivationCrs == nil { + m.NulliferDerivationCrs = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ParticipateResponse) 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 ErrIntOverflowSummoning + } + 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: ParticipateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ParticipateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ParticipateResponse_Position{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Msg = &ParticipateResponse_Position_{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContributeNow", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ParticipateResponse_ContributeNow{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Msg = &ParticipateResponse_ContributeNow_{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Confirm", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ParticipateResponse_Confirm{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Msg = &ParticipateResponse_Confirm_{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ParticipateResponse_Position) 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 ErrIntOverflowSummoning + } + 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: Position: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Position: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) + } + m.Position = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Position |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ConnectedParticipants", wireType) + } + m.ConnectedParticipants = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ConnectedParticipants |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastSlotBid", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LastSlotBid == nil { + m.LastSlotBid = &v1alpha11.Amount{} + } + if err := m.LastSlotBid.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field YourBid", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.YourBid == nil { + m.YourBid = &v1alpha11.Amount{} + } + if err := m.YourBid.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ParticipateResponse_ContributeNow) 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 ErrIntOverflowSummoning + } + 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: ContributeNow: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContributeNow: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSummoning + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSummoning + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Parent == nil { + m.Parent = &CeremonyCrs{} + } + if err := m.Parent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ParticipateResponse_Confirm) 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 ErrIntOverflowSummoning + } + 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: Confirm: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Confirm: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSummoning + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSummoning(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSummoning + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSummoning(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, ErrIntOverflowSummoning + } + 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, ErrIntOverflowSummoning + } + 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, ErrIntOverflowSummoning + } + 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, ErrInvalidLengthSummoning + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupSummoning + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthSummoning + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthSummoning = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSummoning = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupSummoning = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/tx.go b/relayer/chains/penumbra/tx.go index dd90ac098..4475c89a7 100644 --- a/relayer/chains/penumbra/tx.go +++ b/relayer/chains/penumbra/tx.go @@ -2,61 +2,60 @@ package penumbra import ( "context" - "encoding/base64" "errors" "fmt" "math/rand" - "regexp" "strconv" "strings" "time" + sdkerrors "cosmossdk.io/errors" + "cosmossdk.io/store/rootmulti" "github.com/avast/retry-go/v4" abci "github.com/cometbft/cometbft/abci/types" "github.com/cometbft/cometbft/libs/bytes" "github.com/cometbft/cometbft/light" tmcrypto "github.com/cometbft/cometbft/proto/tendermint/crypto" - rpcclient "github.com/cometbft/cometbft/rpc/client" + "github.com/cometbft/cometbft/rpc/client" coretypes "github.com/cometbft/cometbft/rpc/core/types" tmtypes "github.com/cometbft/cometbft/types" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/store/rootmulti" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + legacyerrors "github.com/cosmos/cosmos-sdk/types/errors" cosmosproto "github.com/cosmos/gogoproto/proto" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - commitmenttypes "github.com/cosmos/ibc-go/v7/modules/core/23-commitment/types" - host "github.com/cosmos/ibc-go/v7/modules/core/24-host" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" - tmclient "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + commitmenttypes "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types" + host "github.com/cosmos/ibc-go/v8/modules/core/24-host" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + tmclient "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" ics23 "github.com/cosmos/ics23/go" "github.com/cosmos/relayer/v2/relayer/chains/cosmos" - penumbracrypto "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" - penumbraibctypes "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/ibc/v1alpha1" + penumbrafee "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1alpha1" + penumbraibctypes "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1alpha1" + penumbraasset "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" penumbratypes "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1alpha1" + penumbrardsa "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_rdsa/v1alpha1" + penumbracrypto "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1alpha1" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" ) -// Variables used for retries var ( - rtyAttNum = uint(5) - rtyAtt = retry.Attempts(rtyAttNum) - rtyDel = retry.Delay(time.Millisecond * 400) - rtyErr = retry.LastErrorOnly(true) - numRegex = regexp.MustCompile("[0-9]+") + rtyAttNum = uint(5) + rtyAtt = retry.Attempts(rtyAttNum) + rtyDel = retry.Delay(time.Millisecond * 400) + rtyErr = retry.LastErrorOnly(true) + defaultBroadcastWaitTimeout = 10 * time.Minute errUnknown = "unknown" ) -// Default IBC settings var ( - defaultChainPrefix = commitmenttypes.NewMerklePrefix([]byte("ibc")) defaultDelayPeriod = uint64(0) ) @@ -91,7 +90,11 @@ type intoAny interface { // SendMessage attempts to sign, encode & send a RelayerMessage // This is used extensively in the relayer as an extension of the Provider interface -func (cc *PenumbraProvider) SendMessage(ctx context.Context, msg provider.RelayerMessage, memo string) (*provider.RelayerTxResponse, bool, error) { +func (cc *PenumbraProvider) SendMessage( + ctx context.Context, + msg provider.RelayerMessage, + memo string, +) (*provider.RelayerTxResponse, bool, error) { return cc.SendMessages(ctx, []provider.RelayerMessage{msg}, memo) } @@ -106,89 +109,94 @@ func msgToPenumbraAction(msg sdk.Msg) (*penumbratypes.Action, error) { switch msg.(type) { case *clienttypes.MsgCreateClient: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *clienttypes.MsgUpdateClient: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *conntypes.MsgConnectionOpenInit: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *conntypes.MsgConnectionOpenAck: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *conntypes.MsgConnectionOpenTry: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *conntypes.MsgConnectionOpenConfirm: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *chantypes.MsgChannelOpenInit: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *chantypes.MsgChannelOpenTry: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *chantypes.MsgChannelOpenAck: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *chantypes.MsgChannelOpenConfirm: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *chantypes.MsgChannelCloseInit: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *chantypes.MsgChannelCloseConfirm: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *chantypes.MsgRecvPacket: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil case *chantypes.MsgAcknowledgement: return &penumbratypes.Action{ - Action: &penumbratypes.Action_IbcAction{IbcAction: &penumbraibctypes.IbcAction{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ + RawAction: anyMsg, + }}, + }, nil + case *chantypes.MsgTimeout: + return &penumbratypes.Action{ + Action: &penumbratypes.Action_IbcRelayAction{IbcRelayAction: &penumbraibctypes.IbcRelay{ RawAction: anyMsg, }}, }, nil - default: return nil, fmt.Errorf("unknown message type: %T", msg) } @@ -247,9 +255,12 @@ func (cc *PenumbraProvider) getAnchor(ctx context.Context) (*penumbracrypto.Merk maxHeight := status.SyncInfo.LatestBlockHeight // Generate a random block height to query between 1 and maxHeight - height := rand.Int63n(maxHeight-1) + 1 + height := rand.Int63n(maxHeight - 1) + if height < 0 { + height = 0 + } - path := fmt.Sprintf("shielded_pool/anchor/%d", height) + path := fmt.Sprintf("sct/anchor/%d", height) req := abci.RequestQuery{ Path: "state/key", @@ -260,49 +271,33 @@ func (cc *PenumbraProvider) getAnchor(ctx context.Context) (*penumbracrypto.Merk res, err := cc.QueryABCI(ctx, req) if err != nil { - path := fmt.Sprintf("sct/anchor/%d", height) - - req := abci.RequestQuery{ - Path: "state/key", - Height: maxHeight, - Data: []byte(path), - Prove: false, - } - res, err := cc.QueryABCI(ctx, req) - if err != nil { - return nil, err - } + return nil, err + } - return &penumbracrypto.MerkleRoot{Inner: res.Value[2:]}, nil + if res.Value == nil { + return nil, errors.New("no anchor found for height" + strconv.FormatInt(height, 10)) } return &penumbracrypto.MerkleRoot{Inner: res.Value[2:]}, nil } -func parseEventsFromABCIResponse(resp abci.ResponseDeliverTx) []provider.RelayerEvent { - var events []provider.RelayerEvent +func parseEventsFromABCIResponse(resp abci.ExecTxResult) []provider.RelayerEvent { + events := make([]provider.RelayerEvent, len(resp.Events)) for _, event := range resp.Events { attributes := make(map[string]string) + for _, attribute := range event.Attributes { - // The key and value are base64-encoded strings, so we first have to decode them: - key, err := base64.StdEncoding.DecodeString(string(attribute.Key)) - if err != nil { - continue - } - value, err := base64.StdEncoding.DecodeString(string(attribute.Value)) - if err != nil { - continue - } - attributes[string(key)] = string(value) + attributes[attribute.Key] = attribute.Value } + events = append(events, provider.RelayerEvent{ EventType: event.Type, Attributes: attributes, }) } - return events + return events } func (cc *PenumbraProvider) sendMessagesInner(ctx context.Context, msgs []provider.RelayerMessage, _memo string) (*coretypes.ResultBroadcastTx, error) { @@ -313,10 +308,14 @@ func (cc *PenumbraProvider) sendMessagesInner(ctx context.Context, msgs []provid // will have a signing protocol for this. txBody := penumbratypes.TransactionBody{ - Actions: make([]*penumbratypes.Action, 0), - Fee: &penumbracrypto.Fee{Amount: &penumbracrypto.Amount{Lo: 0, Hi: 0}}, - MemoData: &penumbratypes.MemoData{}, - TransactionParameters: &penumbratypes.TransactionParameters{}, + Actions: make([]*penumbratypes.Action, 0), + TransactionParameters: &penumbratypes.TransactionParameters{ + Fee: &penumbrafee.Fee{ + Amount: &penumbraasset.Amount{Lo: 0, Hi: 0}, + }, + }, + DetectionData: &penumbratypes.DetectionData{}, + Memo: nil, } for _, msg := range PenumbraMsgs(msgs...) { @@ -334,7 +333,7 @@ func (cc *PenumbraProvider) sendMessagesInner(ctx context.Context, msgs []provid tx := &penumbratypes.Transaction{ Body: &txBody, - BindingSig: make([]byte, 64), // use the Cool Signature + BindingSig: &penumbrardsa.BindingSignature{Inner: make([]byte, 64)}, Anchor: anchor, } @@ -589,7 +588,7 @@ func (cc *PenumbraProvider) ConnectionOpenTry(ctx context.Context, dstQueryProvi ClientState: csAny, Counterparty: counterparty, DelayPeriod: defaultDelayPeriod, - CounterpartyVersions: conntypes.ExportedVersionsToProto(conntypes.GetCompatibleVersions()), + CounterpartyVersions: conntypes.GetCompatibleVersions(), ProofHeight: clienttypes.Height{ RevisionNumber: proofHeight.GetRevisionNumber(), RevisionHeight: proofHeight.GetRevisionHeight(), @@ -1389,7 +1388,7 @@ func (cc *PenumbraProvider) MsgConnectionOpenTry(msgOpenInit provider.Connection ClientState: csAny, Counterparty: counterparty, DelayPeriod: defaultDelayPeriod, - CounterpartyVersions: conntypes.ExportedVersionsToProto(conntypes.GetCompatibleVersions()), + CounterpartyVersions: conntypes.GetCompatibleVersions(), ProofHeight: proof.ProofHeight, ProofInit: proof.ConnectionStateProof, ProofClient: proof.ClientStateProof, @@ -1626,15 +1625,19 @@ func (cc *PenumbraProvider) MsgChannelCloseConfirm(msgCloseInit provider.Channel }), nil } -func (cc *PenumbraProvider) MsgUpdateClientHeader(latestHeader provider.IBCHeader, trustedHeight clienttypes.Height, trustedHeader provider.IBCHeader) (ibcexported.ClientMessage, error) { - trustedCosmosHeader, ok := trustedHeader.(PenumbraIBCHeader) +func (cc *PenumbraProvider) MsgUpdateClientHeader( + latestHeader provider.IBCHeader, + trustedHeight clienttypes.Height, + trustedHeader provider.IBCHeader, +) (ibcexported.ClientMessage, error) { + trustedCosmosHeader, ok := trustedHeader.(provider.TendermintIBCHeader) if !ok { - return nil, fmt.Errorf("unsupported IBC trusted header type, expected: PenumbraIBCHeader, actual: %T", trustedHeader) + return nil, fmt.Errorf("unsupported IBC trusted header type, expected: %T, actual: %T", provider.TendermintIBCHeader{}, trustedHeader) } - latestCosmosHeader, ok := latestHeader.(PenumbraIBCHeader) + latestCosmosHeader, ok := latestHeader.(provider.TendermintIBCHeader) if !ok { - return nil, fmt.Errorf("unsupported IBC header type, expected: PenumbraIBCHeader, actual: %T", latestHeader) + return nil, fmt.Errorf("unsupported IBC header type, expected: %T, actual: %T", provider.TendermintIBCHeader{}, latestHeader) } trustedValidatorsProto, err := trustedCosmosHeader.ValidatorSet.ToProto() @@ -1883,7 +1886,7 @@ func (cc *PenumbraProvider) IBCHeaderAtHeight(ctx context.Context, h int64) (pro return nil, err } - return PenumbraIBCHeader{ + return provider.TendermintIBCHeader{ SignedHeader: lightBlock.SignedHeader, ValidatorSet: lightBlock.ValidatorSet, }, nil @@ -2017,35 +2020,15 @@ var JmtSpec = &ics23.ProofSpec{ PrehashKeyBeforeComparison: true, } -var ApphashSpec = &ics23.ProofSpec{ - LeafSpec: &ics23.LeafOp{ - Prefix: nil, - Hash: ics23.HashOp_SHA256, - Length: ics23.LengthOp_NO_PREFIX, - PrehashKey: ics23.HashOp_NO_HASH, - PrehashValue: ics23.HashOp_NO_HASH, - }, - InnerSpec: &ics23.InnerSpec{ - Hash: ics23.HashOp_SHA256, - MaxPrefixLength: 0, - MinPrefixLength: 0, - ChildOrder: []int32{0, 1}, - ChildSize: 32, - EmptyChild: nil, - }, - MinDepth: 0, - MaxDepth: 1, - PrehashKeyBeforeComparison: true, -} - -var PenumbraProofSpecs = []*ics23.ProofSpec{JmtSpec, ApphashSpec} +var PenumbraProofSpecs = []*ics23.ProofSpec{JmtSpec, JmtSpec} // NewClientState creates a new tendermint client state tracking the dst chain. func (cc *PenumbraProvider) NewClientState( dstChainID string, dstUpdateHeader provider.IBCHeader, dstTrustingPeriod, - dstUbdPeriod time.Duration, + dstUbdPeriod, + maxClockDrift time.Duration, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour bool, ) (ibcexported.ClientState, error) { @@ -2057,7 +2040,7 @@ func (cc *PenumbraProvider) NewClientState( TrustLevel: tmclient.NewFractionFromTm(light.DefaultTrustLevel), TrustingPeriod: dstTrustingPeriod, UnbondingPeriod: dstUbdPeriod, - MaxClockDrift: time.Minute * 10, + MaxClockDrift: maxClockDrift, FrozenHeight: clienttypes.ZeroHeight(), LatestHeight: clienttypes.Height{ RevisionNumber: revisionNumber, @@ -2081,7 +2064,7 @@ func (cc *PenumbraProvider) QueryIBCHeader(ctx context.Context, h int64) (provid return nil, err } - return PenumbraIBCHeader{ + return provider.TendermintIBCHeader{ SignedHeader: lightBlock.SignedHeader, ValidatorSet: lightBlock.ValidatorSet, }, nil @@ -2089,10 +2072,11 @@ func (cc *PenumbraProvider) QueryIBCHeader(ctx context.Context, h int64) (provid // QueryABCI performs an ABCI query and returns the appropriate response and error sdk error code. func (cc *PenumbraProvider) QueryABCI(ctx context.Context, req abci.RequestQuery) (abci.ResponseQuery, error) { - opts := rpcclient.ABCIQueryOptions{ + opts := client.ABCIQueryOptions{ Height: req.Height, Prove: req.Prove, } + result, err := cc.RPCClient.ABCIQueryWithOptions(ctx, req.Path, req.Data, opts) if err != nil { return abci.ResponseQuery{}, err @@ -2112,11 +2096,11 @@ func (cc *PenumbraProvider) QueryABCI(ctx context.Context, req abci.RequestQuery func sdkErrorToGRPCError(resp abci.ResponseQuery) error { switch resp.Code { - case sdkerrors.ErrInvalidRequest.ABCICode(): + case legacyerrors.ErrInvalidRequest.ABCICode(): return status.Error(codes.InvalidArgument, resp.Log) - case sdkerrors.ErrUnauthorized.ABCICode(): + case legacyerrors.ErrUnauthorized.ABCICode(): return status.Error(codes.Unauthenticated, resp.Log) - case sdkerrors.ErrKeyNotFound.ABCICode(): + case legacyerrors.ErrKeyNotFound.ABCICode(): return status.Error(codes.NotFound, resp.Log) default: return status.Error(codes.Unknown, resp.Log) @@ -2283,10 +2267,12 @@ func (cc *PenumbraProvider) mkTxResult(resTx *coretypes.ResultTx) (*sdk.TxRespon if err != nil { return nil, err } + p, ok := txbz.(intoAny) if !ok { return nil, fmt.Errorf("expecting a type implementing intoAny, got: %T", txbz) } + any := p.AsAny() return sdk.NewResponseResultTx(resTx, any, ""), nil } diff --git a/relayer/chains/penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.pb.go b/relayer/chains/penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.pb.go new file mode 100644 index 000000000..aad816a9a --- /dev/null +++ b/relayer/chains/penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.pb.go @@ -0,0 +1,4706 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.proto + +package tendermint_proxyv1alpha1 + +import ( + context "context" + fmt "fmt" + crypto "github.com/cometbft/cometbft/proto/tendermint/crypto" + p2p "github.com/cometbft/cometbft/proto/tendermint/p2p" + types "github.com/cometbft/cometbft/proto/tendermint/types" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + types1 "github.com/cosmos/gogoproto/types" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + 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 + +// GetTxRequest is the request type for the GetTx RPC method. +type GetTxRequest struct { + // Hash of transaction to retrieve + Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` + // Include proofs of the transaction's inclusion in the block + Prove bool `protobuf:"varint,2,opt,name=prove,proto3" json:"prove,omitempty"` +} + +func (m *GetTxRequest) Reset() { *m = GetTxRequest{} } +func (m *GetTxRequest) String() string { return proto.CompactTextString(m) } +func (*GetTxRequest) ProtoMessage() {} +func (*GetTxRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{0} +} +func (m *GetTxRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetTxRequest.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 *GetTxRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetTxRequest.Merge(m, src) +} +func (m *GetTxRequest) XXX_Size() int { + return m.Size() +} +func (m *GetTxRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetTxRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetTxRequest proto.InternalMessageInfo + +func (m *GetTxRequest) GetHash() []byte { + if m != nil { + return m.Hash + } + return nil +} + +func (m *GetTxRequest) GetProve() bool { + if m != nil { + return m.Prove + } + return false +} + +// GetTxResponse is the response type for the GetTx RPC method. +type GetTxResponse struct { + // Hash of transaction + Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` + Index uint64 `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"` + TxResult *TxResult `protobuf:"bytes,4,opt,name=tx_result,json=txResult,proto3" json:"tx_result,omitempty"` + Tx []byte `protobuf:"bytes,5,opt,name=tx,proto3" json:"tx,omitempty"` +} + +func (m *GetTxResponse) Reset() { *m = GetTxResponse{} } +func (m *GetTxResponse) String() string { return proto.CompactTextString(m) } +func (*GetTxResponse) ProtoMessage() {} +func (*GetTxResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{1} +} +func (m *GetTxResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetTxResponse.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 *GetTxResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetTxResponse.Merge(m, src) +} +func (m *GetTxResponse) XXX_Size() int { + return m.Size() +} +func (m *GetTxResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetTxResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetTxResponse proto.InternalMessageInfo + +func (m *GetTxResponse) GetHash() []byte { + if m != nil { + return m.Hash + } + return nil +} + +func (m *GetTxResponse) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *GetTxResponse) GetIndex() uint64 { + if m != nil { + return m.Index + } + return 0 +} + +func (m *GetTxResponse) GetTxResult() *TxResult { + if m != nil { + return m.TxResult + } + return nil +} + +func (m *GetTxResponse) GetTx() []byte { + if m != nil { + return m.Tx + } + return nil +} + +type TxResult struct { + Log string `protobuf:"bytes,1,opt,name=log,proto3" json:"log,omitempty"` + GasWanted uint64 `protobuf:"varint,2,opt,name=gas_wanted,json=gasWanted,proto3" json:"gas_wanted,omitempty"` + GasUsed uint64 `protobuf:"varint,3,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"` + Tags []*Tag `protobuf:"bytes,4,rep,name=tags,proto3" json:"tags,omitempty"` +} + +func (m *TxResult) Reset() { *m = TxResult{} } +func (m *TxResult) String() string { return proto.CompactTextString(m) } +func (*TxResult) ProtoMessage() {} +func (*TxResult) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{2} +} +func (m *TxResult) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TxResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TxResult.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 *TxResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_TxResult.Merge(m, src) +} +func (m *TxResult) XXX_Size() int { + return m.Size() +} +func (m *TxResult) XXX_DiscardUnknown() { + xxx_messageInfo_TxResult.DiscardUnknown(m) +} + +var xxx_messageInfo_TxResult proto.InternalMessageInfo + +func (m *TxResult) GetLog() string { + if m != nil { + return m.Log + } + return "" +} + +func (m *TxResult) GetGasWanted() uint64 { + if m != nil { + return m.GasWanted + } + return 0 +} + +func (m *TxResult) GetGasUsed() uint64 { + if m != nil { + return m.GasUsed + } + return 0 +} + +func (m *TxResult) GetTags() []*Tag { + if m != nil { + return m.Tags + } + return nil +} + +type Tag struct { + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + Index bool `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"` +} + +func (m *Tag) Reset() { *m = Tag{} } +func (m *Tag) String() string { return proto.CompactTextString(m) } +func (*Tag) ProtoMessage() {} +func (*Tag) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{3} +} +func (m *Tag) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Tag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Tag.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 *Tag) XXX_Merge(src proto.Message) { + xxx_messageInfo_Tag.Merge(m, src) +} +func (m *Tag) XXX_Size() int { + return m.Size() +} +func (m *Tag) XXX_DiscardUnknown() { + xxx_messageInfo_Tag.DiscardUnknown(m) +} + +var xxx_messageInfo_Tag proto.InternalMessageInfo + +func (m *Tag) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func (m *Tag) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func (m *Tag) GetIndex() bool { + if m != nil { + return m.Index + } + return false +} + +// BroadcastTxAsyncRequest is the request type for the BroadcastTxAsync RPC method. +type BroadcastTxAsyncRequest struct { + Params []byte `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"` + ReqId uint64 `protobuf:"varint,2,opt,name=req_id,json=reqId,proto3" json:"req_id,omitempty"` +} + +func (m *BroadcastTxAsyncRequest) Reset() { *m = BroadcastTxAsyncRequest{} } +func (m *BroadcastTxAsyncRequest) String() string { return proto.CompactTextString(m) } +func (*BroadcastTxAsyncRequest) ProtoMessage() {} +func (*BroadcastTxAsyncRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{4} +} +func (m *BroadcastTxAsyncRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BroadcastTxAsyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BroadcastTxAsyncRequest.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 *BroadcastTxAsyncRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BroadcastTxAsyncRequest.Merge(m, src) +} +func (m *BroadcastTxAsyncRequest) XXX_Size() int { + return m.Size() +} +func (m *BroadcastTxAsyncRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BroadcastTxAsyncRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_BroadcastTxAsyncRequest proto.InternalMessageInfo + +func (m *BroadcastTxAsyncRequest) GetParams() []byte { + if m != nil { + return m.Params + } + return nil +} + +func (m *BroadcastTxAsyncRequest) GetReqId() uint64 { + if m != nil { + return m.ReqId + } + return 0 +} + +// BroadcastTxAsyncResponse is the response type for the BroadcastTxAsync RPC method. +type BroadcastTxAsyncResponse struct { + Code uint64 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` + Hash []byte `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"` +} + +func (m *BroadcastTxAsyncResponse) Reset() { *m = BroadcastTxAsyncResponse{} } +func (m *BroadcastTxAsyncResponse) String() string { return proto.CompactTextString(m) } +func (*BroadcastTxAsyncResponse) ProtoMessage() {} +func (*BroadcastTxAsyncResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{5} +} +func (m *BroadcastTxAsyncResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BroadcastTxAsyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BroadcastTxAsyncResponse.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 *BroadcastTxAsyncResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BroadcastTxAsyncResponse.Merge(m, src) +} +func (m *BroadcastTxAsyncResponse) XXX_Size() int { + return m.Size() +} +func (m *BroadcastTxAsyncResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BroadcastTxAsyncResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_BroadcastTxAsyncResponse proto.InternalMessageInfo + +func (m *BroadcastTxAsyncResponse) GetCode() uint64 { + if m != nil { + return m.Code + } + return 0 +} + +func (m *BroadcastTxAsyncResponse) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *BroadcastTxAsyncResponse) GetLog() string { + if m != nil { + return m.Log + } + return "" +} + +func (m *BroadcastTxAsyncResponse) GetHash() []byte { + if m != nil { + return m.Hash + } + return nil +} + +// BroadcastTxSyncRequest is the request type for the BroadcastTxSync RPC method. +type BroadcastTxSyncRequest struct { + Params []byte `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"` + ReqId uint64 `protobuf:"varint,2,opt,name=req_id,json=reqId,proto3" json:"req_id,omitempty"` +} + +func (m *BroadcastTxSyncRequest) Reset() { *m = BroadcastTxSyncRequest{} } +func (m *BroadcastTxSyncRequest) String() string { return proto.CompactTextString(m) } +func (*BroadcastTxSyncRequest) ProtoMessage() {} +func (*BroadcastTxSyncRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{6} +} +func (m *BroadcastTxSyncRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BroadcastTxSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BroadcastTxSyncRequest.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 *BroadcastTxSyncRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BroadcastTxSyncRequest.Merge(m, src) +} +func (m *BroadcastTxSyncRequest) XXX_Size() int { + return m.Size() +} +func (m *BroadcastTxSyncRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BroadcastTxSyncRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_BroadcastTxSyncRequest proto.InternalMessageInfo + +func (m *BroadcastTxSyncRequest) GetParams() []byte { + if m != nil { + return m.Params + } + return nil +} + +func (m *BroadcastTxSyncRequest) GetReqId() uint64 { + if m != nil { + return m.ReqId + } + return 0 +} + +// BroadcastTxSyncResponse is the response type for the BroadcastTxSync RPC method. +type BroadcastTxSyncResponse struct { + Code uint64 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` + Hash []byte `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"` +} + +func (m *BroadcastTxSyncResponse) Reset() { *m = BroadcastTxSyncResponse{} } +func (m *BroadcastTxSyncResponse) String() string { return proto.CompactTextString(m) } +func (*BroadcastTxSyncResponse) ProtoMessage() {} +func (*BroadcastTxSyncResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{7} +} +func (m *BroadcastTxSyncResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BroadcastTxSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BroadcastTxSyncResponse.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 *BroadcastTxSyncResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BroadcastTxSyncResponse.Merge(m, src) +} +func (m *BroadcastTxSyncResponse) XXX_Size() int { + return m.Size() +} +func (m *BroadcastTxSyncResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BroadcastTxSyncResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_BroadcastTxSyncResponse proto.InternalMessageInfo + +func (m *BroadcastTxSyncResponse) GetCode() uint64 { + if m != nil { + return m.Code + } + return 0 +} + +func (m *BroadcastTxSyncResponse) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *BroadcastTxSyncResponse) GetLog() string { + if m != nil { + return m.Log + } + return "" +} + +func (m *BroadcastTxSyncResponse) GetHash() []byte { + if m != nil { + return m.Hash + } + return nil +} + +// GetStatusRequest is the request type for the Query/GetStatus RPC method. +type GetStatusRequest struct { +} + +func (m *GetStatusRequest) Reset() { *m = GetStatusRequest{} } +func (m *GetStatusRequest) String() string { return proto.CompactTextString(m) } +func (*GetStatusRequest) ProtoMessage() {} +func (*GetStatusRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{8} +} +func (m *GetStatusRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetStatusRequest.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 *GetStatusRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetStatusRequest.Merge(m, src) +} +func (m *GetStatusRequest) XXX_Size() int { + return m.Size() +} +func (m *GetStatusRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetStatusRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetStatusRequest proto.InternalMessageInfo + +// GetStatusResponse is the response type for the Query/GetStatus RPC method. +type GetStatusResponse struct { + NodeInfo *p2p.DefaultNodeInfo `protobuf:"bytes,1,opt,name=node_info,json=nodeInfo,proto3" json:"node_info,omitempty"` + SyncInfo *SyncInfo `protobuf:"bytes,2,opt,name=sync_info,json=syncInfo,proto3" json:"sync_info,omitempty"` + ValidatorInfo *types.Validator `protobuf:"bytes,3,opt,name=validator_info,json=validatorInfo,proto3" json:"validator_info,omitempty"` +} + +func (m *GetStatusResponse) Reset() { *m = GetStatusResponse{} } +func (m *GetStatusResponse) String() string { return proto.CompactTextString(m) } +func (*GetStatusResponse) ProtoMessage() {} +func (*GetStatusResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{9} +} +func (m *GetStatusResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetStatusResponse.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 *GetStatusResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetStatusResponse.Merge(m, src) +} +func (m *GetStatusResponse) XXX_Size() int { + return m.Size() +} +func (m *GetStatusResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetStatusResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetStatusResponse proto.InternalMessageInfo + +func (m *GetStatusResponse) GetNodeInfo() *p2p.DefaultNodeInfo { + if m != nil { + return m.NodeInfo + } + return nil +} + +func (m *GetStatusResponse) GetSyncInfo() *SyncInfo { + if m != nil { + return m.SyncInfo + } + return nil +} + +func (m *GetStatusResponse) GetValidatorInfo() *types.Validator { + if m != nil { + return m.ValidatorInfo + } + return nil +} + +type SyncInfo struct { + LatestBlockHash []byte `protobuf:"bytes,1,opt,name=latest_block_hash,json=latestBlockHash,proto3" json:"latest_block_hash,omitempty"` + LatestAppHash []byte `protobuf:"bytes,2,opt,name=latest_app_hash,json=latestAppHash,proto3" json:"latest_app_hash,omitempty"` + LatestBlockHeight uint64 `protobuf:"varint,3,opt,name=latest_block_height,json=latestBlockHeight,proto3" json:"latest_block_height,omitempty"` + LatestBlockTime *types1.Timestamp `protobuf:"bytes,4,opt,name=latest_block_time,json=latestBlockTime,proto3" json:"latest_block_time,omitempty"` + // These are implemented in tendermint, but not + // in tendermint-rpc. + // bytes earliest_block_hash = 5; + // bytes earliest_app_hash = 6; + // uint64 earliest_block_height = 7; + // google.protobuf.Timestamp earliest_block_time = 8; + CatchingUp bool `protobuf:"varint,9,opt,name=catching_up,json=catchingUp,proto3" json:"catching_up,omitempty"` +} + +func (m *SyncInfo) Reset() { *m = SyncInfo{} } +func (m *SyncInfo) String() string { return proto.CompactTextString(m) } +func (*SyncInfo) ProtoMessage() {} +func (*SyncInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{10} +} +func (m *SyncInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SyncInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SyncInfo.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 *SyncInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyncInfo.Merge(m, src) +} +func (m *SyncInfo) XXX_Size() int { + return m.Size() +} +func (m *SyncInfo) XXX_DiscardUnknown() { + xxx_messageInfo_SyncInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_SyncInfo proto.InternalMessageInfo + +func (m *SyncInfo) GetLatestBlockHash() []byte { + if m != nil { + return m.LatestBlockHash + } + return nil +} + +func (m *SyncInfo) GetLatestAppHash() []byte { + if m != nil { + return m.LatestAppHash + } + return nil +} + +func (m *SyncInfo) GetLatestBlockHeight() uint64 { + if m != nil { + return m.LatestBlockHeight + } + return 0 +} + +func (m *SyncInfo) GetLatestBlockTime() *types1.Timestamp { + if m != nil { + return m.LatestBlockTime + } + return nil +} + +func (m *SyncInfo) GetCatchingUp() bool { + if m != nil { + return m.CatchingUp + } + return false +} + +// ABCIQueryRequest defines the request structure for the ABCIQuery gRPC query. +type ABCIQueryRequest struct { + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"` + Height int64 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"` + Prove bool `protobuf:"varint,4,opt,name=prove,proto3" json:"prove,omitempty"` +} + +func (m *ABCIQueryRequest) Reset() { *m = ABCIQueryRequest{} } +func (m *ABCIQueryRequest) String() string { return proto.CompactTextString(m) } +func (*ABCIQueryRequest) ProtoMessage() {} +func (*ABCIQueryRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{11} +} +func (m *ABCIQueryRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ABCIQueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ABCIQueryRequest.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 *ABCIQueryRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ABCIQueryRequest.Merge(m, src) +} +func (m *ABCIQueryRequest) XXX_Size() int { + return m.Size() +} +func (m *ABCIQueryRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ABCIQueryRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ABCIQueryRequest proto.InternalMessageInfo + +func (m *ABCIQueryRequest) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *ABCIQueryRequest) GetPath() string { + if m != nil { + return m.Path + } + return "" +} + +func (m *ABCIQueryRequest) GetHeight() int64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *ABCIQueryRequest) GetProve() bool { + if m != nil { + return m.Prove + } + return false +} + +// ABCIQueryResponse defines the response structure for the ABCIQuery gRPC query. +// +// Note: This type is a duplicate of the ResponseQuery proto type defined in +// Tendermint. +type ABCIQueryResponse struct { + Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` + Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` + Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` + Index int64 `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"` + Key []byte `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"` + ProofOps *crypto.ProofOps `protobuf:"bytes,8,opt,name=proof_ops,json=proofOps,proto3" json:"proof_ops,omitempty"` + Height int64 `protobuf:"varint,9,opt,name=height,proto3" json:"height,omitempty"` + Codespace string `protobuf:"bytes,10,opt,name=codespace,proto3" json:"codespace,omitempty"` +} + +func (m *ABCIQueryResponse) Reset() { *m = ABCIQueryResponse{} } +func (m *ABCIQueryResponse) String() string { return proto.CompactTextString(m) } +func (*ABCIQueryResponse) ProtoMessage() {} +func (*ABCIQueryResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{12} +} +func (m *ABCIQueryResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ABCIQueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ABCIQueryResponse.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 *ABCIQueryResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ABCIQueryResponse.Merge(m, src) +} +func (m *ABCIQueryResponse) XXX_Size() int { + return m.Size() +} +func (m *ABCIQueryResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ABCIQueryResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ABCIQueryResponse proto.InternalMessageInfo + +func (m *ABCIQueryResponse) GetCode() uint32 { + if m != nil { + return m.Code + } + return 0 +} + +func (m *ABCIQueryResponse) GetLog() string { + if m != nil { + return m.Log + } + return "" +} + +func (m *ABCIQueryResponse) GetInfo() string { + if m != nil { + return m.Info + } + return "" +} + +func (m *ABCIQueryResponse) GetIndex() int64 { + if m != nil { + return m.Index + } + return 0 +} + +func (m *ABCIQueryResponse) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func (m *ABCIQueryResponse) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func (m *ABCIQueryResponse) GetProofOps() *crypto.ProofOps { + if m != nil { + return m.ProofOps + } + return nil +} + +func (m *ABCIQueryResponse) GetHeight() int64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *ABCIQueryResponse) GetCodespace() string { + if m != nil { + return m.Codespace + } + return "" +} + +// GetBlockByHeightRequest is the request type for the Query/GetBlockByHeight RPC method. +type GetBlockByHeightRequest struct { + Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *GetBlockByHeightRequest) Reset() { *m = GetBlockByHeightRequest{} } +func (m *GetBlockByHeightRequest) String() string { return proto.CompactTextString(m) } +func (*GetBlockByHeightRequest) ProtoMessage() {} +func (*GetBlockByHeightRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{13} +} +func (m *GetBlockByHeightRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetBlockByHeightRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetBlockByHeightRequest.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 *GetBlockByHeightRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetBlockByHeightRequest.Merge(m, src) +} +func (m *GetBlockByHeightRequest) XXX_Size() int { + return m.Size() +} +func (m *GetBlockByHeightRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetBlockByHeightRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetBlockByHeightRequest proto.InternalMessageInfo + +func (m *GetBlockByHeightRequest) GetHeight() int64 { + if m != nil { + return m.Height + } + return 0 +} + +// GetBlockByHeightResponse is the response type for the Query/GetBlockByHeight RPC method. +type GetBlockByHeightResponse struct { + BlockId *types.BlockID `protobuf:"bytes,1,opt,name=block_id,json=blockId,proto3" json:"block_id,omitempty"` + Block *types.Block `protobuf:"bytes,2,opt,name=block,proto3" json:"block,omitempty"` +} + +func (m *GetBlockByHeightResponse) Reset() { *m = GetBlockByHeightResponse{} } +func (m *GetBlockByHeightResponse) String() string { return proto.CompactTextString(m) } +func (*GetBlockByHeightResponse) ProtoMessage() {} +func (*GetBlockByHeightResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_7e4c505f155f813d, []int{14} +} +func (m *GetBlockByHeightResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetBlockByHeightResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetBlockByHeightResponse.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 *GetBlockByHeightResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetBlockByHeightResponse.Merge(m, src) +} +func (m *GetBlockByHeightResponse) XXX_Size() int { + return m.Size() +} +func (m *GetBlockByHeightResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetBlockByHeightResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetBlockByHeightResponse proto.InternalMessageInfo + +func (m *GetBlockByHeightResponse) GetBlockId() *types.BlockID { + if m != nil { + return m.BlockId + } + return nil +} + +func (m *GetBlockByHeightResponse) GetBlock() *types.Block { + if m != nil { + return m.Block + } + return nil +} + +func init() { + proto.RegisterType((*GetTxRequest)(nil), "penumbra.util.tendermint_proxy.v1alpha1.GetTxRequest") + proto.RegisterType((*GetTxResponse)(nil), "penumbra.util.tendermint_proxy.v1alpha1.GetTxResponse") + proto.RegisterType((*TxResult)(nil), "penumbra.util.tendermint_proxy.v1alpha1.TxResult") + proto.RegisterType((*Tag)(nil), "penumbra.util.tendermint_proxy.v1alpha1.Tag") + proto.RegisterType((*BroadcastTxAsyncRequest)(nil), "penumbra.util.tendermint_proxy.v1alpha1.BroadcastTxAsyncRequest") + proto.RegisterType((*BroadcastTxAsyncResponse)(nil), "penumbra.util.tendermint_proxy.v1alpha1.BroadcastTxAsyncResponse") + proto.RegisterType((*BroadcastTxSyncRequest)(nil), "penumbra.util.tendermint_proxy.v1alpha1.BroadcastTxSyncRequest") + proto.RegisterType((*BroadcastTxSyncResponse)(nil), "penumbra.util.tendermint_proxy.v1alpha1.BroadcastTxSyncResponse") + proto.RegisterType((*GetStatusRequest)(nil), "penumbra.util.tendermint_proxy.v1alpha1.GetStatusRequest") + proto.RegisterType((*GetStatusResponse)(nil), "penumbra.util.tendermint_proxy.v1alpha1.GetStatusResponse") + proto.RegisterType((*SyncInfo)(nil), "penumbra.util.tendermint_proxy.v1alpha1.SyncInfo") + proto.RegisterType((*ABCIQueryRequest)(nil), "penumbra.util.tendermint_proxy.v1alpha1.ABCIQueryRequest") + proto.RegisterType((*ABCIQueryResponse)(nil), "penumbra.util.tendermint_proxy.v1alpha1.ABCIQueryResponse") + proto.RegisterType((*GetBlockByHeightRequest)(nil), "penumbra.util.tendermint_proxy.v1alpha1.GetBlockByHeightRequest") + proto.RegisterType((*GetBlockByHeightResponse)(nil), "penumbra.util.tendermint_proxy.v1alpha1.GetBlockByHeightResponse") +} + +func init() { + proto.RegisterFile("penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.proto", fileDescriptor_7e4c505f155f813d) +} + +var fileDescriptor_7e4c505f155f813d = []byte{ + // 1192 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xcd, 0x6f, 0x1b, 0x45, + 0x14, 0xcf, 0xfa, 0xab, 0xf6, 0x4b, 0xd3, 0x26, 0x4b, 0x49, 0x5d, 0xd3, 0xba, 0xd1, 0x1e, 0x4a, + 0xf8, 0xda, 0x55, 0xcc, 0x87, 0x8a, 0x41, 0xd0, 0xb8, 0x15, 0x69, 0x90, 0x28, 0x66, 0xe3, 0x14, + 0x09, 0x45, 0xb2, 0x26, 0xbb, 0x93, 0xf5, 0xaa, 0xeb, 0xdd, 0xc9, 0xce, 0xac, 0xb1, 0x4f, 0x08, + 0xa9, 0x7f, 0x00, 0x27, 0x04, 0x57, 0x8e, 0xdc, 0xf8, 0x2f, 0x10, 0xa7, 0x1e, 0x39, 0xa2, 0x44, + 0x5c, 0xb8, 0x71, 0xe2, 0x8a, 0xe6, 0x63, 0xed, 0x8d, 0x9d, 0x48, 0x76, 0x10, 0xb7, 0xb7, 0xf3, + 0xde, 0xef, 0xcd, 0x6f, 0xde, 0xbc, 0xf7, 0x1b, 0x1b, 0x3e, 0x22, 0x38, 0x4c, 0xfa, 0x87, 0x31, + 0xb2, 0x12, 0xe6, 0x07, 0x16, 0xc3, 0xa1, 0x8b, 0xe3, 0xbe, 0x1f, 0xb2, 0x2e, 0x89, 0xa3, 0xe1, + 0xc8, 0x1a, 0x6c, 0xa1, 0x80, 0xf4, 0xd0, 0xd6, 0x8c, 0xc7, 0x24, 0x71, 0xc4, 0x22, 0xfd, 0xd5, + 0x14, 0x6f, 0x72, 0xbc, 0x39, 0x13, 0x95, 0xe2, 0x6b, 0x77, 0xbd, 0x28, 0xf2, 0x02, 0x6c, 0x09, + 0xd8, 0x61, 0x72, 0x64, 0x31, 0xbf, 0x8f, 0x29, 0x43, 0x7d, 0x22, 0x33, 0xd5, 0xee, 0x4c, 0xb0, + 0x96, 0x13, 0x8f, 0x08, 0x8b, 0x78, 0x6c, 0x74, 0xa4, 0xdc, 0xb5, 0x8c, 0x9b, 0x34, 0x88, 0xc5, + 0x46, 0x04, 0x53, 0xe5, 0xbb, 0x9d, 0xf1, 0x89, 0x75, 0xeb, 0x30, 0x88, 0x9c, 0x67, 0x17, 0x7a, + 0xb3, 0xd8, 0x8d, 0x19, 0xef, 0x00, 0x05, 0xbe, 0x8b, 0x58, 0x14, 0xcb, 0x08, 0xe3, 0x3e, 0x5c, + 0xdd, 0xc1, 0xac, 0x33, 0xb4, 0xf1, 0x71, 0x82, 0x29, 0xd3, 0x75, 0x28, 0xf4, 0x10, 0xed, 0x55, + 0xb5, 0x0d, 0x6d, 0xf3, 0xaa, 0x2d, 0x6c, 0xfd, 0x06, 0x14, 0x49, 0x1c, 0x0d, 0x70, 0x35, 0xb7, + 0xa1, 0x6d, 0x96, 0x6d, 0xf9, 0x61, 0xfc, 0xa2, 0xc1, 0x8a, 0x82, 0x52, 0x12, 0x85, 0x14, 0x9f, + 0x8b, 0x5d, 0x87, 0x52, 0x0f, 0xfb, 0x5e, 0x8f, 0x09, 0x70, 0xc1, 0x56, 0x5f, 0x3c, 0xa7, 0x1f, + 0xba, 0x78, 0x58, 0xcd, 0x8b, 0x65, 0xf9, 0xa1, 0x3f, 0x81, 0x0a, 0x1b, 0x76, 0x63, 0x4c, 0x93, + 0x80, 0x55, 0x0b, 0x1b, 0xda, 0xe6, 0x72, 0x63, 0xcb, 0x9c, 0xf3, 0x12, 0x4c, 0xc1, 0x24, 0x09, + 0x98, 0x5d, 0x66, 0xca, 0xd2, 0xaf, 0x41, 0x8e, 0x0d, 0xab, 0x45, 0xc1, 0x27, 0xc7, 0x86, 0xc6, + 0x0f, 0x1a, 0x94, 0xd3, 0x30, 0x7d, 0x15, 0xf2, 0x41, 0xe4, 0x09, 0xb6, 0x15, 0x9b, 0x9b, 0xfa, + 0x1d, 0x00, 0x0f, 0xd1, 0xee, 0xd7, 0x28, 0x64, 0xd8, 0x55, 0x84, 0x2b, 0x1e, 0xa2, 0x5f, 0x8a, + 0x05, 0xfd, 0x16, 0x94, 0xb9, 0x3b, 0xa1, 0xd8, 0x55, 0xb4, 0xaf, 0x78, 0x88, 0xee, 0x53, 0xec, + 0xea, 0x0f, 0xa0, 0xc0, 0x90, 0x47, 0xab, 0x85, 0x8d, 0xfc, 0xe6, 0x72, 0xe3, 0xcd, 0xf9, 0x39, + 0x23, 0xcf, 0x16, 0x48, 0xe3, 0x21, 0xe4, 0x3b, 0xc8, 0xe3, 0xa4, 0x9e, 0xe1, 0x91, 0x2a, 0x21, + 0x37, 0x79, 0xa5, 0x06, 0x28, 0x48, 0x64, 0xf5, 0xaf, 0xda, 0xf2, 0xe3, 0x6c, 0xfd, 0xca, 0xaa, + 0x7e, 0xc6, 0x63, 0xb8, 0xd9, 0x8a, 0x23, 0xe4, 0x3a, 0x88, 0xb2, 0xce, 0x70, 0x9b, 0x8e, 0x42, + 0x27, 0xbd, 0xd8, 0x75, 0x28, 0x11, 0x14, 0xa3, 0x3e, 0x55, 0xb9, 0xd5, 0x97, 0xfe, 0x32, 0x94, + 0x62, 0x7c, 0xdc, 0xf5, 0xd3, 0xf3, 0x16, 0x63, 0x7c, 0xbc, 0xeb, 0x1a, 0x3d, 0xa8, 0xce, 0x66, + 0x9a, 0xdc, 0xb3, 0x13, 0xb9, 0x58, 0x24, 0x2a, 0xd8, 0xc2, 0xe6, 0x6b, 0x2e, 0x62, 0x48, 0x91, + 0x14, 0x76, 0x5a, 0xe0, 0xfc, 0xa4, 0xc0, 0x69, 0x87, 0x14, 0x26, 0x1d, 0x62, 0xec, 0xc0, 0x7a, + 0x66, 0xa7, 0xbd, 0xcb, 0x53, 0xf6, 0xce, 0x1c, 0x7e, 0xef, 0xff, 0x63, 0xac, 0xc3, 0xea, 0x0e, + 0x66, 0x7b, 0x0c, 0xb1, 0x84, 0x2a, 0xae, 0xc6, 0x9f, 0x1a, 0xac, 0x65, 0x16, 0xd5, 0xbe, 0x1f, + 0x42, 0x25, 0x8c, 0x5c, 0xdc, 0xf5, 0xc3, 0xa3, 0x48, 0x6c, 0xbe, 0xdc, 0xb8, 0x9b, 0xe9, 0x06, + 0x93, 0x34, 0x88, 0xf9, 0x08, 0x1f, 0xa1, 0x24, 0x60, 0x4f, 0x22, 0x17, 0xef, 0x86, 0x47, 0x91, + 0x5d, 0x0e, 0x95, 0xc5, 0xa7, 0x81, 0xd7, 0x5d, 0xa2, 0x73, 0x0b, 0x4e, 0x03, 0x3f, 0xbf, 0xcc, + 0x47, 0x95, 0xa5, 0xb7, 0xe0, 0xda, 0x78, 0xfc, 0x65, 0xd2, 0xbc, 0x48, 0xfa, 0x4a, 0x96, 0x92, + 0x94, 0x8f, 0xa7, 0x69, 0x9c, 0xbd, 0x32, 0x86, 0xf0, 0x1c, 0xc6, 0x3f, 0x1a, 0x94, 0xd3, 0xd4, + 0xfa, 0xeb, 0xb0, 0x16, 0x20, 0x86, 0x29, 0xeb, 0x0a, 0x49, 0xea, 0x66, 0xa6, 0xff, 0xba, 0x74, + 0xb4, 0xf8, 0xfa, 0x63, 0x2e, 0x04, 0xf7, 0x40, 0x2d, 0x75, 0x11, 0x21, 0x32, 0x52, 0x56, 0x7e, + 0x45, 0x2e, 0x6f, 0x13, 0x22, 0xe2, 0x4c, 0x78, 0xe9, 0x6c, 0x4e, 0xa9, 0x1e, 0x72, 0xde, 0xd6, + 0xb2, 0x59, 0xa5, 0x90, 0x7c, 0x32, 0xc5, 0x81, 0x2b, 0xaf, 0x92, 0x8e, 0x9a, 0x29, 0x65, 0xd9, + 0x4c, 0x65, 0xd9, 0xec, 0xa4, 0xb2, 0x7c, 0x86, 0x1f, 0x5f, 0xd5, 0xef, 0xc2, 0xb2, 0x83, 0x98, + 0xd3, 0xf3, 0x43, 0xaf, 0x9b, 0x90, 0x6a, 0x45, 0x8c, 0x15, 0xa4, 0x4b, 0xfb, 0xc4, 0xe8, 0xc1, + 0xea, 0x76, 0xeb, 0xe1, 0xee, 0x17, 0x09, 0x8e, 0x47, 0x19, 0xb5, 0x14, 0x3d, 0xa4, 0x65, 0x7a, + 0x48, 0x87, 0x02, 0x41, 0x4c, 0x9e, 0xae, 0x62, 0x0b, 0x3b, 0xa3, 0x82, 0xfc, 0x1c, 0xf9, 0xac, + 0x0a, 0x4a, 0x65, 0x2d, 0x64, 0x95, 0xf5, 0xdb, 0x1c, 0xac, 0x65, 0xb6, 0x3a, 0xa7, 0x87, 0x57, + 0x54, 0x0f, 0x9f, 0xdb, 0xaf, 0xe2, 0x66, 0x0b, 0x72, 0x77, 0x6e, 0x4f, 0xb4, 0xa2, 0x28, 0x36, + 0x57, 0x5a, 0xab, 0x94, 0xa6, 0x74, 0x8e, 0xd2, 0x5c, 0xc9, 0x2a, 0xcd, 0x7d, 0xa8, 0x88, 0xa7, + 0xaa, 0x1b, 0x11, 0x5a, 0x2d, 0xcf, 0x36, 0x8c, 0x7c, 0xce, 0xcc, 0x36, 0x8f, 0xf9, 0x9c, 0x50, + 0xbb, 0x4c, 0x94, 0x95, 0x39, 0x75, 0xe5, 0xcc, 0xa9, 0x6f, 0x43, 0x85, 0xb3, 0xa7, 0x04, 0x39, + 0xb8, 0x0a, 0x82, 0xe8, 0x64, 0xe1, 0xd3, 0x42, 0x39, 0xb7, 0x9a, 0x37, 0xb6, 0xe0, 0xe6, 0x0e, + 0x96, 0xd7, 0xd3, 0x1a, 0xc9, 0xab, 0xce, 0xc8, 0x82, 0x4a, 0xab, 0x65, 0xd3, 0x1a, 0xdf, 0x40, + 0x75, 0x16, 0xa2, 0x8a, 0xf7, 0x0e, 0x94, 0x65, 0x7b, 0xf8, 0xae, 0x9a, 0xc3, 0x5b, 0xb3, 0x4d, + 0x2f, 0xa0, 0xbb, 0x8f, 0xec, 0x2b, 0x22, 0x74, 0xd7, 0xd5, 0xdf, 0x82, 0xa2, 0x30, 0xd5, 0xf0, + 0xdd, 0xbc, 0x00, 0x62, 0xcb, 0xa8, 0xc6, 0xdf, 0x25, 0x58, 0xef, 0x8c, 0x23, 0xda, 0x7c, 0x1e, + 0xf7, 0x70, 0x3c, 0xf0, 0x1d, 0xac, 0x3f, 0xd7, 0xa0, 0x32, 0x96, 0x07, 0xfd, 0xfd, 0xb9, 0xa7, + 0x78, 0x5a, 0x67, 0x6a, 0xcd, 0xcb, 0x40, 0x65, 0x11, 0x8c, 0x25, 0xfd, 0x47, 0x0d, 0x56, 0xa7, + 0x65, 0x5d, 0x7f, 0x30, 0x77, 0xca, 0x0b, 0xde, 0x96, 0xda, 0xf6, 0x7f, 0xc8, 0x30, 0xe6, 0xf6, + 0xbd, 0x06, 0xd7, 0xa7, 0xf4, 0x5b, 0xff, 0xf8, 0x32, 0x89, 0x33, 0x4f, 0x48, 0xed, 0xc1, 0xe5, + 0x13, 0x8c, 0x89, 0x0d, 0xa1, 0x28, 0x7e, 0xe7, 0xe8, 0xef, 0x2e, 0x52, 0xfb, 0xf1, 0x4f, 0xaa, + 0xda, 0x7b, 0x8b, 0xc2, 0xc6, 0x3b, 0xf3, 0xae, 0x19, 0x0b, 0xc1, 0x02, 0x5d, 0x33, 0xad, 0x53, + 0x0b, 0x74, 0xcd, 0x8c, 0xee, 0xa8, 0xae, 0x99, 0x9e, 0xac, 0x05, 0xba, 0xe6, 0x82, 0x39, 0x5e, + 0xa0, 0x6b, 0x2e, 0x1a, 0x6b, 0x63, 0xa9, 0xf5, 0x3c, 0xff, 0xeb, 0x49, 0x5d, 0x7b, 0x71, 0x52, + 0xd7, 0xfe, 0x38, 0xa9, 0x6b, 0xdf, 0x9d, 0xd6, 0x97, 0x5e, 0x9c, 0xd6, 0x97, 0x7e, 0x3f, 0xad, + 0x2f, 0xc1, 0x1b, 0x4e, 0xd4, 0x9f, 0x77, 0x8b, 0xd6, 0x8d, 0xa9, 0xc1, 0x6d, 0xf3, 0x27, 0xa3, + 0xad, 0x7d, 0x15, 0x78, 0x3e, 0xeb, 0x25, 0x87, 0xa6, 0x13, 0xf5, 0x2d, 0x27, 0xa2, 0xfd, 0x88, + 0x5a, 0x31, 0x0e, 0xd0, 0x08, 0xc7, 0xd6, 0xa0, 0x31, 0x36, 0x9d, 0x1e, 0xf2, 0x43, 0x6a, 0xcd, + 0xf9, 0x77, 0xe3, 0x83, 0x69, 0x4f, 0xea, 0xf8, 0x29, 0x97, 0x6f, 0xef, 0x77, 0x7e, 0xce, 0xdd, + 0x6b, 0xa7, 0xac, 0xf7, 0x39, 0xeb, 0x29, 0x6a, 0xe6, 0x53, 0x15, 0xfe, 0xdb, 0x24, 0xf0, 0x80, + 0x07, 0x1e, 0x4c, 0x05, 0x1e, 0xa4, 0x81, 0x27, 0xb9, 0xc6, 0x7c, 0x81, 0x07, 0x3b, 0xed, 0xd6, + 0x67, 0x98, 0x21, 0xfe, 0x90, 0xfd, 0x95, 0x7b, 0x2d, 0x05, 0x35, 0x9b, 0x1c, 0xd5, 0x6c, 0x4e, + 0xc1, 0x9a, 0xcd, 0x14, 0x77, 0x58, 0x12, 0x4f, 0xec, 0xdb, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, + 0x63, 0xa4, 0xeb, 0x62, 0x72, 0x0d, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// TendermintProxyServiceClient is the client API for TendermintProxyService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type TendermintProxyServiceClient interface { + // Status queries the current status. + GetStatus(ctx context.Context, in *GetStatusRequest, opts ...grpc.CallOption) (*GetStatusResponse, error) + // Broadcast a transaction asynchronously. + BroadcastTxAsync(ctx context.Context, in *BroadcastTxAsyncRequest, opts ...grpc.CallOption) (*BroadcastTxAsyncResponse, error) + // Broadcast a transaction synchronously. + BroadcastTxSync(ctx context.Context, in *BroadcastTxSyncRequest, opts ...grpc.CallOption) (*BroadcastTxSyncResponse, error) + // Fetch a transaction by hash. + GetTx(ctx context.Context, in *GetTxRequest, opts ...grpc.CallOption) (*GetTxResponse, error) + // ABCIQuery defines a query handler that supports ABCI queries directly to the + // application, bypassing Tendermint completely. The ABCI query must contain + // a valid and supported path, including app, custom, p2p, and store. + ABCIQuery(ctx context.Context, in *ABCIQueryRequest, opts ...grpc.CallOption) (*ABCIQueryResponse, error) + // GetBlockByHeight queries block for given height. + GetBlockByHeight(ctx context.Context, in *GetBlockByHeightRequest, opts ...grpc.CallOption) (*GetBlockByHeightResponse, error) +} + +type tendermintProxyServiceClient struct { + cc grpc1.ClientConn +} + +func NewTendermintProxyServiceClient(cc grpc1.ClientConn) TendermintProxyServiceClient { + return &tendermintProxyServiceClient{cc} +} + +func (c *tendermintProxyServiceClient) GetStatus(ctx context.Context, in *GetStatusRequest, opts ...grpc.CallOption) (*GetStatusResponse, error) { + out := new(GetStatusResponse) + err := c.cc.Invoke(ctx, "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/GetStatus", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *tendermintProxyServiceClient) BroadcastTxAsync(ctx context.Context, in *BroadcastTxAsyncRequest, opts ...grpc.CallOption) (*BroadcastTxAsyncResponse, error) { + out := new(BroadcastTxAsyncResponse) + err := c.cc.Invoke(ctx, "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/BroadcastTxAsync", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *tendermintProxyServiceClient) BroadcastTxSync(ctx context.Context, in *BroadcastTxSyncRequest, opts ...grpc.CallOption) (*BroadcastTxSyncResponse, error) { + out := new(BroadcastTxSyncResponse) + err := c.cc.Invoke(ctx, "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/BroadcastTxSync", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *tendermintProxyServiceClient) GetTx(ctx context.Context, in *GetTxRequest, opts ...grpc.CallOption) (*GetTxResponse, error) { + out := new(GetTxResponse) + err := c.cc.Invoke(ctx, "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/GetTx", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *tendermintProxyServiceClient) ABCIQuery(ctx context.Context, in *ABCIQueryRequest, opts ...grpc.CallOption) (*ABCIQueryResponse, error) { + out := new(ABCIQueryResponse) + err := c.cc.Invoke(ctx, "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/ABCIQuery", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *tendermintProxyServiceClient) GetBlockByHeight(ctx context.Context, in *GetBlockByHeightRequest, opts ...grpc.CallOption) (*GetBlockByHeightResponse, error) { + out := new(GetBlockByHeightResponse) + err := c.cc.Invoke(ctx, "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/GetBlockByHeight", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// TendermintProxyServiceServer is the server API for TendermintProxyService service. +type TendermintProxyServiceServer interface { + // Status queries the current status. + GetStatus(context.Context, *GetStatusRequest) (*GetStatusResponse, error) + // Broadcast a transaction asynchronously. + BroadcastTxAsync(context.Context, *BroadcastTxAsyncRequest) (*BroadcastTxAsyncResponse, error) + // Broadcast a transaction synchronously. + BroadcastTxSync(context.Context, *BroadcastTxSyncRequest) (*BroadcastTxSyncResponse, error) + // Fetch a transaction by hash. + GetTx(context.Context, *GetTxRequest) (*GetTxResponse, error) + // ABCIQuery defines a query handler that supports ABCI queries directly to the + // application, bypassing Tendermint completely. The ABCI query must contain + // a valid and supported path, including app, custom, p2p, and store. + ABCIQuery(context.Context, *ABCIQueryRequest) (*ABCIQueryResponse, error) + // GetBlockByHeight queries block for given height. + GetBlockByHeight(context.Context, *GetBlockByHeightRequest) (*GetBlockByHeightResponse, error) +} + +// UnimplementedTendermintProxyServiceServer can be embedded to have forward compatible implementations. +type UnimplementedTendermintProxyServiceServer struct { +} + +func (*UnimplementedTendermintProxyServiceServer) GetStatus(ctx context.Context, req *GetStatusRequest) (*GetStatusResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetStatus not implemented") +} +func (*UnimplementedTendermintProxyServiceServer) BroadcastTxAsync(ctx context.Context, req *BroadcastTxAsyncRequest) (*BroadcastTxAsyncResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method BroadcastTxAsync not implemented") +} +func (*UnimplementedTendermintProxyServiceServer) BroadcastTxSync(ctx context.Context, req *BroadcastTxSyncRequest) (*BroadcastTxSyncResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method BroadcastTxSync not implemented") +} +func (*UnimplementedTendermintProxyServiceServer) GetTx(ctx context.Context, req *GetTxRequest) (*GetTxResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTx not implemented") +} +func (*UnimplementedTendermintProxyServiceServer) ABCIQuery(ctx context.Context, req *ABCIQueryRequest) (*ABCIQueryResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ABCIQuery not implemented") +} +func (*UnimplementedTendermintProxyServiceServer) GetBlockByHeight(ctx context.Context, req *GetBlockByHeightRequest) (*GetBlockByHeightResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetBlockByHeight not implemented") +} + +func RegisterTendermintProxyServiceServer(s grpc1.Server, srv TendermintProxyServiceServer) { + s.RegisterService(&_TendermintProxyService_serviceDesc, srv) +} + +func _TendermintProxyService_GetStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TendermintProxyServiceServer).GetStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/GetStatus", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TendermintProxyServiceServer).GetStatus(ctx, req.(*GetStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TendermintProxyService_BroadcastTxAsync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BroadcastTxAsyncRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TendermintProxyServiceServer).BroadcastTxAsync(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/BroadcastTxAsync", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TendermintProxyServiceServer).BroadcastTxAsync(ctx, req.(*BroadcastTxAsyncRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TendermintProxyService_BroadcastTxSync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BroadcastTxSyncRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TendermintProxyServiceServer).BroadcastTxSync(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/BroadcastTxSync", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TendermintProxyServiceServer).BroadcastTxSync(ctx, req.(*BroadcastTxSyncRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TendermintProxyService_GetTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetTxRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TendermintProxyServiceServer).GetTx(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/GetTx", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TendermintProxyServiceServer).GetTx(ctx, req.(*GetTxRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TendermintProxyService_ABCIQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ABCIQueryRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TendermintProxyServiceServer).ABCIQuery(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/ABCIQuery", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TendermintProxyServiceServer).ABCIQuery(ctx, req.(*ABCIQueryRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TendermintProxyService_GetBlockByHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetBlockByHeightRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TendermintProxyServiceServer).GetBlockByHeight(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService/GetBlockByHeight", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TendermintProxyServiceServer).GetBlockByHeight(ctx, req.(*GetBlockByHeightRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _TendermintProxyService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "penumbra.util.tendermint_proxy.v1alpha1.TendermintProxyService", + HandlerType: (*TendermintProxyServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetStatus", + Handler: _TendermintProxyService_GetStatus_Handler, + }, + { + MethodName: "BroadcastTxAsync", + Handler: _TendermintProxyService_BroadcastTxAsync_Handler, + }, + { + MethodName: "BroadcastTxSync", + Handler: _TendermintProxyService_BroadcastTxSync_Handler, + }, + { + MethodName: "GetTx", + Handler: _TendermintProxyService_GetTx_Handler, + }, + { + MethodName: "ABCIQuery", + Handler: _TendermintProxyService_ABCIQuery_Handler, + }, + { + MethodName: "GetBlockByHeight", + Handler: _TendermintProxyService_GetBlockByHeight_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.proto", +} + +func (m *GetTxRequest) 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 *GetTxRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetTxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Prove { + i-- + if m.Prove { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetTxResponse) 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 *GetTxResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetTxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Tx) > 0 { + i -= len(m.Tx) + copy(dAtA[i:], m.Tx) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Tx))) + i-- + dAtA[i] = 0x2a + } + if m.TxResult != nil { + { + size, err := m.TxResult.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTendermintProxy(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.Index != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x18 + } + if m.Height != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TxResult) 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 *TxResult) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TxResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Tags) > 0 { + for iNdEx := len(m.Tags) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Tags[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTendermintProxy(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if m.GasUsed != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.GasUsed)) + i-- + dAtA[i] = 0x18 + } + if m.GasWanted != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.GasWanted)) + i-- + dAtA[i] = 0x10 + } + if len(m.Log) > 0 { + i -= len(m.Log) + copy(dAtA[i:], m.Log) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Log))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Tag) 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 *Tag) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Tag) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Index { + i-- + if m.Index { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BroadcastTxAsyncRequest) 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 *BroadcastTxAsyncRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BroadcastTxAsyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ReqId != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.ReqId)) + i-- + dAtA[i] = 0x10 + } + if len(m.Params) > 0 { + i -= len(m.Params) + copy(dAtA[i:], m.Params) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Params))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BroadcastTxAsyncResponse) 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 *BroadcastTxAsyncResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BroadcastTxAsyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0x22 + } + if len(m.Log) > 0 { + i -= len(m.Log) + copy(dAtA[i:], m.Log) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Log))) + i-- + dAtA[i] = 0x1a + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 + } + if m.Code != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.Code)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BroadcastTxSyncRequest) 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 *BroadcastTxSyncRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BroadcastTxSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ReqId != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.ReqId)) + i-- + dAtA[i] = 0x10 + } + if len(m.Params) > 0 { + i -= len(m.Params) + copy(dAtA[i:], m.Params) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Params))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BroadcastTxSyncResponse) 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 *BroadcastTxSyncResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BroadcastTxSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0x22 + } + if len(m.Log) > 0 { + i -= len(m.Log) + copy(dAtA[i:], m.Log) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Log))) + i-- + dAtA[i] = 0x1a + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 + } + if m.Code != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.Code)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GetStatusRequest) 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 *GetStatusRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *GetStatusResponse) 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 *GetStatusResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ValidatorInfo != nil { + { + size, err := m.ValidatorInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTendermintProxy(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.SyncInfo != nil { + { + size, err := m.SyncInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTendermintProxy(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.NodeInfo != nil { + { + size, err := m.NodeInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTendermintProxy(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SyncInfo) 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 *SyncInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SyncInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CatchingUp { + i-- + if m.CatchingUp { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } + if m.LatestBlockTime != nil { + { + size, err := m.LatestBlockTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTendermintProxy(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.LatestBlockHeight != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.LatestBlockHeight)) + i-- + dAtA[i] = 0x18 + } + if len(m.LatestAppHash) > 0 { + i -= len(m.LatestAppHash) + copy(dAtA[i:], m.LatestAppHash) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.LatestAppHash))) + i-- + dAtA[i] = 0x12 + } + if len(m.LatestBlockHash) > 0 { + i -= len(m.LatestBlockHash) + copy(dAtA[i:], m.LatestBlockHash) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.LatestBlockHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ABCIQueryRequest) 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 *ABCIQueryRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ABCIQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Prove { + i-- + if m.Prove { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.Height != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x18 + } + if len(m.Path) > 0 { + i -= len(m.Path) + copy(dAtA[i:], m.Path) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Path))) + i-- + dAtA[i] = 0x12 + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ABCIQueryResponse) 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 *ABCIQueryResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ABCIQueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Codespace) > 0 { + i -= len(m.Codespace) + copy(dAtA[i:], m.Codespace) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Codespace))) + i-- + dAtA[i] = 0x52 + } + if m.Height != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x48 + } + if m.ProofOps != nil { + { + size, err := m.ProofOps.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTendermintProxy(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x3a + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x32 + } + if m.Index != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x28 + } + if len(m.Info) > 0 { + i -= len(m.Info) + copy(dAtA[i:], m.Info) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Info))) + i-- + dAtA[i] = 0x22 + } + if len(m.Log) > 0 { + i -= len(m.Log) + copy(dAtA[i:], m.Log) + i = encodeVarintTendermintProxy(dAtA, i, uint64(len(m.Log))) + i-- + dAtA[i] = 0x1a + } + if m.Code != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.Code)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GetBlockByHeightRequest) 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 *GetBlockByHeightRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetBlockByHeightRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintTendermintProxy(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GetBlockByHeightResponse) 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 *GetBlockByHeightResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetBlockByHeightResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Block != nil { + { + size, err := m.Block.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTendermintProxy(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.BlockId != nil { + { + size, err := m.BlockId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTendermintProxy(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintTendermintProxy(dAtA []byte, offset int, v uint64) int { + offset -= sovTendermintProxy(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GetTxRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.Prove { + n += 2 + } + return n +} + +func (m *GetTxResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovTendermintProxy(uint64(m.Height)) + } + if m.Index != 0 { + n += 1 + sovTendermintProxy(uint64(m.Index)) + } + if m.TxResult != nil { + l = m.TxResult.Size() + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.Tx) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + return n +} + +func (m *TxResult) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Log) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.GasWanted != 0 { + n += 1 + sovTendermintProxy(uint64(m.GasWanted)) + } + if m.GasUsed != 0 { + n += 1 + sovTendermintProxy(uint64(m.GasUsed)) + } + if len(m.Tags) > 0 { + for _, e := range m.Tags { + l = e.Size() + n += 1 + l + sovTendermintProxy(uint64(l)) + } + } + return n +} + +func (m *Tag) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.Index { + n += 2 + } + return n +} + +func (m *BroadcastTxAsyncRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Params) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.ReqId != 0 { + n += 1 + sovTendermintProxy(uint64(m.ReqId)) + } + return n +} + +func (m *BroadcastTxAsyncResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Code != 0 { + n += 1 + sovTendermintProxy(uint64(m.Code)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.Log) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + return n +} + +func (m *BroadcastTxSyncRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Params) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.ReqId != 0 { + n += 1 + sovTendermintProxy(uint64(m.ReqId)) + } + return n +} + +func (m *BroadcastTxSyncResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Code != 0 { + n += 1 + sovTendermintProxy(uint64(m.Code)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.Log) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + return n +} + +func (m *GetStatusRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *GetStatusResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NodeInfo != nil { + l = m.NodeInfo.Size() + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.SyncInfo != nil { + l = m.SyncInfo.Size() + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.ValidatorInfo != nil { + l = m.ValidatorInfo.Size() + n += 1 + l + sovTendermintProxy(uint64(l)) + } + return n +} + +func (m *SyncInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.LatestBlockHash) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.LatestAppHash) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.LatestBlockHeight != 0 { + n += 1 + sovTendermintProxy(uint64(m.LatestBlockHeight)) + } + if m.LatestBlockTime != nil { + l = m.LatestBlockTime.Size() + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.CatchingUp { + n += 2 + } + return n +} + +func (m *ABCIQueryRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.Path) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovTendermintProxy(uint64(m.Height)) + } + if m.Prove { + n += 2 + } + return n +} + +func (m *ABCIQueryResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Code != 0 { + n += 1 + sovTendermintProxy(uint64(m.Code)) + } + l = len(m.Log) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.Info) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.Index != 0 { + n += 1 + sovTendermintProxy(uint64(m.Index)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.ProofOps != nil { + l = m.ProofOps.Size() + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovTendermintProxy(uint64(m.Height)) + } + l = len(m.Codespace) + if l > 0 { + n += 1 + l + sovTendermintProxy(uint64(l)) + } + return n +} + +func (m *GetBlockByHeightRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovTendermintProxy(uint64(m.Height)) + } + return n +} + +func (m *GetBlockByHeightResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockId != nil { + l = m.BlockId.Size() + n += 1 + l + sovTendermintProxy(uint64(l)) + } + if m.Block != nil { + l = m.Block.Size() + n += 1 + l + sovTendermintProxy(uint64(l)) + } + return n +} + +func sovTendermintProxy(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTendermintProxy(x uint64) (n int) { + return sovTendermintProxy(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GetTxRequest) 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 ErrIntOverflowTendermintProxy + } + 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: GetTxRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetTxRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Prove", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Prove = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetTxResponse) 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 ErrIntOverflowTendermintProxy + } + 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: GetTxResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetTxResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxResult", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TxResult == nil { + m.TxResult = &TxResult{} + } + if err := m.TxResult.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tx = append(m.Tx[:0], dAtA[iNdEx:postIndex]...) + if m.Tx == nil { + m.Tx = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TxResult) 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 ErrIntOverflowTendermintProxy + } + 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: TxResult: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TxResult: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + 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 ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Log = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasWanted", wireType) + } + m.GasWanted = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasWanted |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + m.GasUsed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasUsed |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tags = append(m.Tags, &Tag{}) + if err := m.Tags[len(m.Tags)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Tag) 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 ErrIntOverflowTendermintProxy + } + 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: Tag: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Tag: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Index = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BroadcastTxAsyncRequest) 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 ErrIntOverflowTendermintProxy + } + 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: BroadcastTxAsyncRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BroadcastTxAsyncRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Params = append(m.Params[:0], dAtA[iNdEx:postIndex]...) + if m.Params == nil { + m.Params = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReqId", wireType) + } + m.ReqId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ReqId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BroadcastTxAsyncResponse) 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 ErrIntOverflowTendermintProxy + } + 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: BroadcastTxAsyncResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BroadcastTxAsyncResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + m.Code = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Code |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + 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 ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Log = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BroadcastTxSyncRequest) 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 ErrIntOverflowTendermintProxy + } + 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: BroadcastTxSyncRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BroadcastTxSyncRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Params = append(m.Params[:0], dAtA[iNdEx:postIndex]...) + if m.Params == nil { + m.Params = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReqId", wireType) + } + m.ReqId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ReqId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BroadcastTxSyncResponse) 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 ErrIntOverflowTendermintProxy + } + 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: BroadcastTxSyncResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BroadcastTxSyncResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + m.Code = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Code |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + 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 ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Log = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetStatusRequest) 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 ErrIntOverflowTendermintProxy + } + 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: GetStatusRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetStatusResponse) 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 ErrIntOverflowTendermintProxy + } + 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: GetStatusResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NodeInfo == nil { + m.NodeInfo = &p2p.DefaultNodeInfo{} + } + if err := m.NodeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncInfo == nil { + m.SyncInfo = &SyncInfo{} + } + if err := m.SyncInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorInfo == nil { + m.ValidatorInfo = &types.Validator{} + } + if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyncInfo) 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 ErrIntOverflowTendermintProxy + } + 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: SyncInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockHash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LatestBlockHash = append(m.LatestBlockHash[:0], dAtA[iNdEx:postIndex]...) + if m.LatestBlockHash == nil { + m.LatestBlockHash = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestAppHash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LatestAppHash = append(m.LatestAppHash[:0], dAtA[iNdEx:postIndex]...) + if m.LatestAppHash == nil { + m.LatestAppHash = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockHeight", wireType) + } + m.LatestBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LatestBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LatestBlockTime == nil { + m.LatestBlockTime = &types1.Timestamp{} + } + if err := m.LatestBlockTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CatchingUp", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CatchingUp = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ABCIQueryRequest) 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 ErrIntOverflowTendermintProxy + } + 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: ABCIQueryRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ABCIQueryRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + 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 ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Path = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Prove", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Prove = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ABCIQueryResponse) 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 ErrIntOverflowTendermintProxy + } + 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: ABCIQueryResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ABCIQueryResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + m.Code = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Code |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + 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 ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Log = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + 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 ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Info = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofOps", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProofOps == nil { + m.ProofOps = &crypto.ProofOps{} + } + if err := m.ProofOps.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + 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 ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Codespace = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetBlockByHeightRequest) 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 ErrIntOverflowTendermintProxy + } + 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: GetBlockByHeightRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetBlockByHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetBlockByHeightResponse) 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 ErrIntOverflowTendermintProxy + } + 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: GetBlockByHeightResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetBlockByHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockId == nil { + m.BlockId = &types.BlockID{} + } + if err := m.BlockId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTendermintProxy + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTendermintProxy + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTendermintProxy + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = &types.Block{} + } + if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTendermintProxy(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTendermintProxy + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTendermintProxy(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, ErrIntOverflowTendermintProxy + } + 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, ErrIntOverflowTendermintProxy + } + 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, ErrIntOverflowTendermintProxy + } + 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, ErrInvalidLengthTendermintProxy + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTendermintProxy + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTendermintProxy + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTendermintProxy = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTendermintProxy = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTendermintProxy = fmt.Errorf("proto: unexpected end of group") +) diff --git a/relayer/chains/penumbra/view/v1alpha1/view.pb.go b/relayer/chains/penumbra/view/v1alpha1/view.pb.go index 35056567e..b4c3285e5 100644 --- a/relayer/chains/penumbra/view/v1alpha1/view.pb.go +++ b/relayer/chains/penumbra/view/v1alpha1/view.pb.go @@ -8,12 +8,20 @@ import ( fmt "fmt" grpc1 "github.com/cosmos/gogoproto/grpc" proto "github.com/cosmos/gogoproto/proto" - v1alpha14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/chain/v1alpha1" - v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/crypto/v1alpha1" - v1alpha15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/dex/v1alpha1" - v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/ibc/v1alpha1" - v1alpha13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/stake/v1alpha1" + v1alpha110 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/app/v1alpha1" + v1alpha15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1" + v1alpha111 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/chain/v1alpha1" + v1alpha19 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/dex/v1alpha1" + v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1alpha1" + v1alpha14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1alpha1" + v1alpha112 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1alpha1" + v1alpha113 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1alpha1" + v1alpha18 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1alpha1" + v1alpha13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1" + v1alpha17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1" v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1alpha1" + v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/txhash/v1alpha1" + v1alpha16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1alpha1" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" @@ -188,7 +196,7 @@ func (m *BroadcastTransactionRequest) GetAwaitDetection() bool { type BroadcastTransactionResponse struct { // The hash of the transaction that was broadcast. - Id *v1alpha1.Id `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Id *v1alpha11.TransactionId `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // The height in which the transaction was detected as included in the chain, if any. // Will not be included unless await_detection was true. DetectionHeight uint64 `protobuf:"varint,2,opt,name=detection_height,json=detectionHeight,proto3" json:"detection_height,omitempty"` @@ -227,7 +235,7 @@ func (m *BroadcastTransactionResponse) XXX_DiscardUnknown() { var xxx_messageInfo_BroadcastTransactionResponse proto.InternalMessageInfo -func (m *BroadcastTransactionResponse) GetId() *v1alpha1.Id { +func (m *BroadcastTransactionResponse) GetId() *v1alpha11.TransactionId { if m != nil { return m.Id } @@ -245,19 +253,23 @@ type TransactionPlannerRequest struct { // The expiry height for the requested TransactionPlan ExpiryHeight uint64 `protobuf:"varint,1,opt,name=expiry_height,json=expiryHeight,proto3" json:"expiry_height,omitempty"` // The fee for the requested TransactionPlan, if any. - Fee *v1alpha11.Fee `protobuf:"bytes,2,opt,name=fee,proto3" json:"fee,omitempty"` - // The memo for the requested TransactionPlan + Fee *v1alpha12.Fee `protobuf:"bytes,2,opt,name=fee,proto3" json:"fee,omitempty"` + // The memo for the requested TransactionPlan. + // The memo must be unspecified unless `outputs` is nonempty. Memo *v1alpha1.MemoPlaintext `protobuf:"bytes,3,opt,name=memo,proto3" json:"memo,omitempty"` - // Types that are valid to be assigned to XAccountGroupId: - // *TransactionPlannerRequest_AccountGroupId - XAccountGroupId isTransactionPlannerRequest_XAccountGroupId `protobuf_oneof:"_account_group_id"` + // If present, only spends funds from the given account. + Source *v1alpha13.AddressIndex `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"` // Request contents - Outputs []*TransactionPlannerRequest_Output `protobuf:"bytes,20,rep,name=outputs,proto3" json:"outputs,omitempty"` - Swaps []*TransactionPlannerRequest_Swap `protobuf:"bytes,30,rep,name=swaps,proto3" json:"swaps,omitempty"` - SwapClaims []*TransactionPlannerRequest_SwapClaim `protobuf:"bytes,31,rep,name=swap_claims,json=swapClaims,proto3" json:"swap_claims,omitempty"` - Delegations []*TransactionPlannerRequest_Delegate `protobuf:"bytes,40,rep,name=delegations,proto3" json:"delegations,omitempty"` - Undelegations []*TransactionPlannerRequest_Undelegate `protobuf:"bytes,50,rep,name=undelegations,proto3" json:"undelegations,omitempty"` - IbcActions []*v1alpha12.IbcAction `protobuf:"bytes,60,rep,name=ibc_actions,json=ibcActions,proto3" json:"ibc_actions,omitempty"` + Outputs []*TransactionPlannerRequest_Output `protobuf:"bytes,20,rep,name=outputs,proto3" json:"outputs,omitempty"` + Swaps []*TransactionPlannerRequest_Swap `protobuf:"bytes,30,rep,name=swaps,proto3" json:"swaps,omitempty"` + SwapClaims []*TransactionPlannerRequest_SwapClaim `protobuf:"bytes,31,rep,name=swap_claims,json=swapClaims,proto3" json:"swap_claims,omitempty"` + Delegations []*TransactionPlannerRequest_Delegate `protobuf:"bytes,40,rep,name=delegations,proto3" json:"delegations,omitempty"` + Undelegations []*TransactionPlannerRequest_Undelegate `protobuf:"bytes,50,rep,name=undelegations,proto3" json:"undelegations,omitempty"` + IbcRelayActions []*v1alpha14.IbcRelay `protobuf:"bytes,60,rep,name=ibc_relay_actions,json=ibcRelayActions,proto3" json:"ibc_relay_actions,omitempty"` + Ics20Withdrawals []*v1alpha14.Ics20Withdrawal `protobuf:"bytes,61,rep,name=ics20_withdrawals,json=ics20Withdrawals,proto3" json:"ics20_withdrawals,omitempty"` + PositionOpens []*TransactionPlannerRequest_PositionOpen `protobuf:"bytes,70,rep,name=position_opens,json=positionOpens,proto3" json:"position_opens,omitempty"` + PositionCloses []*TransactionPlannerRequest_PositionClose `protobuf:"bytes,71,rep,name=position_closes,json=positionCloses,proto3" json:"position_closes,omitempty"` + PositionWithdraws []*TransactionPlannerRequest_PositionWithdraw `protobuf:"bytes,72,rep,name=position_withdraws,json=positionWithdraws,proto3" json:"position_withdraws,omitempty"` } func (m *TransactionPlannerRequest) Reset() { *m = TransactionPlannerRequest{} } @@ -293,25 +305,6 @@ func (m *TransactionPlannerRequest) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionPlannerRequest proto.InternalMessageInfo -type isTransactionPlannerRequest_XAccountGroupId interface { - isTransactionPlannerRequest_XAccountGroupId() - MarshalTo([]byte) (int, error) - Size() int -} - -type TransactionPlannerRequest_AccountGroupId struct { - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,14,opt,name=account_group_id,json=accountGroupId,proto3,oneof" json:"account_group_id,omitempty"` -} - -func (*TransactionPlannerRequest_AccountGroupId) isTransactionPlannerRequest_XAccountGroupId() {} - -func (m *TransactionPlannerRequest) GetXAccountGroupId() isTransactionPlannerRequest_XAccountGroupId { - if m != nil { - return m.XAccountGroupId - } - return nil -} - func (m *TransactionPlannerRequest) GetExpiryHeight() uint64 { if m != nil { return m.ExpiryHeight @@ -319,7 +312,7 @@ func (m *TransactionPlannerRequest) GetExpiryHeight() uint64 { return 0 } -func (m *TransactionPlannerRequest) GetFee() *v1alpha11.Fee { +func (m *TransactionPlannerRequest) GetFee() *v1alpha12.Fee { if m != nil { return m.Fee } @@ -333,9 +326,9 @@ func (m *TransactionPlannerRequest) GetMemo() *v1alpha1.MemoPlaintext { return nil } -func (m *TransactionPlannerRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if x, ok := m.GetXAccountGroupId().(*TransactionPlannerRequest_AccountGroupId); ok { - return x.AccountGroupId +func (m *TransactionPlannerRequest) GetSource() *v1alpha13.AddressIndex { + if m != nil { + return m.Source } return nil } @@ -375,26 +368,47 @@ func (m *TransactionPlannerRequest) GetUndelegations() []*TransactionPlannerRequ return nil } -func (m *TransactionPlannerRequest) GetIbcActions() []*v1alpha12.IbcAction { +func (m *TransactionPlannerRequest) GetIbcRelayActions() []*v1alpha14.IbcRelay { + if m != nil { + return m.IbcRelayActions + } + return nil +} + +func (m *TransactionPlannerRequest) GetIcs20Withdrawals() []*v1alpha14.Ics20Withdrawal { + if m != nil { + return m.Ics20Withdrawals + } + return nil +} + +func (m *TransactionPlannerRequest) GetPositionOpens() []*TransactionPlannerRequest_PositionOpen { + if m != nil { + return m.PositionOpens + } + return nil +} + +func (m *TransactionPlannerRequest) GetPositionCloses() []*TransactionPlannerRequest_PositionClose { if m != nil { - return m.IbcActions + return m.PositionCloses } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*TransactionPlannerRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*TransactionPlannerRequest_AccountGroupId)(nil), +func (m *TransactionPlannerRequest) GetPositionWithdraws() []*TransactionPlannerRequest_PositionWithdraw { + if m != nil { + return m.PositionWithdraws } + return nil } // Request message subtypes type TransactionPlannerRequest_Output struct { // The amount and denomination in which the Output is issued. - Value *v1alpha11.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + Value *v1alpha15.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` // The address to which Output will be sent. - Address *v1alpha11.Address `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` + Address *v1alpha13.Address `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` } func (m *TransactionPlannerRequest_Output) Reset() { *m = TransactionPlannerRequest_Output{} } @@ -430,14 +444,14 @@ func (m *TransactionPlannerRequest_Output) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionPlannerRequest_Output proto.InternalMessageInfo -func (m *TransactionPlannerRequest_Output) GetValue() *v1alpha11.Value { +func (m *TransactionPlannerRequest_Output) GetValue() *v1alpha15.Value { if m != nil { return m.Value } return nil } -func (m *TransactionPlannerRequest_Output) GetAddress() *v1alpha11.Address { +func (m *TransactionPlannerRequest_Output) GetAddress() *v1alpha13.Address { if m != nil { return m.Address } @@ -445,12 +459,14 @@ func (m *TransactionPlannerRequest_Output) GetAddress() *v1alpha11.Address { } type TransactionPlannerRequest_Swap struct { - // The amount and denomination to be traded in the Swap. - Value *v1alpha11.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + // The input amount and denomination to be traded in the Swap. + Value *v1alpha15.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` // The denomination to be received as a Output of the Swap. - TargetAsset *v1alpha11.AssetId `protobuf:"bytes,2,opt,name=target_asset,json=targetAsset,proto3" json:"target_asset,omitempty"` - // An optional fee to be paid for performing the Swap. - Fee *v1alpha11.Fee `protobuf:"bytes,3,opt,name=fee,proto3" json:"fee,omitempty"` + TargetAsset *v1alpha15.AssetId `protobuf:"bytes,2,opt,name=target_asset,json=targetAsset,proto3" json:"target_asset,omitempty"` + // The pre-paid fee to be paid for claiming the Swap outputs. + Fee *v1alpha12.Fee `protobuf:"bytes,3,opt,name=fee,proto3" json:"fee,omitempty"` + // The address to which swap claim output will be sent. + ClaimAddress *v1alpha13.Address `protobuf:"bytes,4,opt,name=claim_address,json=claimAddress,proto3" json:"claim_address,omitempty"` } func (m *TransactionPlannerRequest_Swap) Reset() { *m = TransactionPlannerRequest_Swap{} } @@ -486,32 +502,39 @@ func (m *TransactionPlannerRequest_Swap) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionPlannerRequest_Swap proto.InternalMessageInfo -func (m *TransactionPlannerRequest_Swap) GetValue() *v1alpha11.Value { +func (m *TransactionPlannerRequest_Swap) GetValue() *v1alpha15.Value { if m != nil { return m.Value } return nil } -func (m *TransactionPlannerRequest_Swap) GetTargetAsset() *v1alpha11.AssetId { +func (m *TransactionPlannerRequest_Swap) GetTargetAsset() *v1alpha15.AssetId { if m != nil { return m.TargetAsset } return nil } -func (m *TransactionPlannerRequest_Swap) GetFee() *v1alpha11.Fee { +func (m *TransactionPlannerRequest_Swap) GetFee() *v1alpha12.Fee { if m != nil { return m.Fee } return nil } +func (m *TransactionPlannerRequest_Swap) GetClaimAddress() *v1alpha13.Address { + if m != nil { + return m.ClaimAddress + } + return nil +} + type TransactionPlannerRequest_SwapClaim struct { // SwapCommitment to identify the Swap to be claimed. // Use the commitment from the Swap message: - // penumbra.core.dex.v1alpha1.Swap.body.payload.commitment. - SwapCommitment *v1alpha11.StateCommitment `protobuf:"bytes,1,opt,name=swap_commitment,json=swapCommitment,proto3" json:"swap_commitment,omitempty"` + // penumbra.core.component.dex.v1alpha1.Swap.body.payload.commitment. + SwapCommitment *v1alpha16.StateCommitment `protobuf:"bytes,1,opt,name=swap_commitment,json=swapCommitment,proto3" json:"swap_commitment,omitempty"` } func (m *TransactionPlannerRequest_SwapClaim) Reset() { *m = TransactionPlannerRequest_SwapClaim{} } @@ -547,7 +570,7 @@ func (m *TransactionPlannerRequest_SwapClaim) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionPlannerRequest_SwapClaim proto.InternalMessageInfo -func (m *TransactionPlannerRequest_SwapClaim) GetSwapCommitment() *v1alpha11.StateCommitment { +func (m *TransactionPlannerRequest_SwapClaim) GetSwapCommitment() *v1alpha16.StateCommitment { if m != nil { return m.SwapCommitment } @@ -555,8 +578,8 @@ func (m *TransactionPlannerRequest_SwapClaim) GetSwapCommitment() *v1alpha11.Sta } type TransactionPlannerRequest_Delegate struct { - Amount *v1alpha11.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` - RateData *v1alpha13.RateData `protobuf:"bytes,3,opt,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"` + Amount *v1alpha17.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` + RateData *v1alpha18.RateData `protobuf:"bytes,3,opt,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"` } func (m *TransactionPlannerRequest_Delegate) Reset() { *m = TransactionPlannerRequest_Delegate{} } @@ -592,14 +615,14 @@ func (m *TransactionPlannerRequest_Delegate) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionPlannerRequest_Delegate proto.InternalMessageInfo -func (m *TransactionPlannerRequest_Delegate) GetAmount() *v1alpha11.Amount { +func (m *TransactionPlannerRequest_Delegate) GetAmount() *v1alpha17.Amount { if m != nil { return m.Amount } return nil } -func (m *TransactionPlannerRequest_Delegate) GetRateData() *v1alpha13.RateData { +func (m *TransactionPlannerRequest_Delegate) GetRateData() *v1alpha18.RateData { if m != nil { return m.RateData } @@ -607,8 +630,8 @@ func (m *TransactionPlannerRequest_Delegate) GetRateData() *v1alpha13.RateData { } type TransactionPlannerRequest_Undelegate struct { - Value *v1alpha11.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` - RateData *v1alpha13.RateData `protobuf:"bytes,2,opt,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"` + Value *v1alpha15.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + RateData *v1alpha18.RateData `protobuf:"bytes,2,opt,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"` } func (m *TransactionPlannerRequest_Undelegate) Reset() { *m = TransactionPlannerRequest_Undelegate{} } @@ -644,20 +667,184 @@ func (m *TransactionPlannerRequest_Undelegate) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionPlannerRequest_Undelegate proto.InternalMessageInfo -func (m *TransactionPlannerRequest_Undelegate) GetValue() *v1alpha11.Value { +func (m *TransactionPlannerRequest_Undelegate) GetValue() *v1alpha15.Value { if m != nil { return m.Value } return nil } -func (m *TransactionPlannerRequest_Undelegate) GetRateData() *v1alpha13.RateData { +func (m *TransactionPlannerRequest_Undelegate) GetRateData() *v1alpha18.RateData { if m != nil { return m.RateData } return nil } +type TransactionPlannerRequest_PositionOpen struct { + // Contains the data defining the position, sufficient to compute its `PositionId`. + // + // Positions are immutable, so the `PositionData` (and hence the `PositionId`) + // are unchanged over the entire lifetime of the position. + Position *v1alpha19.Position `protobuf:"bytes,1,opt,name=position,proto3" json:"position,omitempty"` +} + +func (m *TransactionPlannerRequest_PositionOpen) Reset() { + *m = TransactionPlannerRequest_PositionOpen{} +} +func (m *TransactionPlannerRequest_PositionOpen) String() string { return proto.CompactTextString(m) } +func (*TransactionPlannerRequest_PositionOpen) ProtoMessage() {} +func (*TransactionPlannerRequest_PositionOpen) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{4, 5} +} +func (m *TransactionPlannerRequest_PositionOpen) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TransactionPlannerRequest_PositionOpen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TransactionPlannerRequest_PositionOpen.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 *TransactionPlannerRequest_PositionOpen) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionPlannerRequest_PositionOpen.Merge(m, src) +} +func (m *TransactionPlannerRequest_PositionOpen) XXX_Size() int { + return m.Size() +} +func (m *TransactionPlannerRequest_PositionOpen) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionPlannerRequest_PositionOpen.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionPlannerRequest_PositionOpen proto.InternalMessageInfo + +func (m *TransactionPlannerRequest_PositionOpen) GetPosition() *v1alpha19.Position { + if m != nil { + return m.Position + } + return nil +} + +type TransactionPlannerRequest_PositionClose struct { + // The position to close. + PositionId *v1alpha19.PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` +} + +func (m *TransactionPlannerRequest_PositionClose) Reset() { + *m = TransactionPlannerRequest_PositionClose{} +} +func (m *TransactionPlannerRequest_PositionClose) String() string { return proto.CompactTextString(m) } +func (*TransactionPlannerRequest_PositionClose) ProtoMessage() {} +func (*TransactionPlannerRequest_PositionClose) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{4, 6} +} +func (m *TransactionPlannerRequest_PositionClose) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TransactionPlannerRequest_PositionClose) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TransactionPlannerRequest_PositionClose.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 *TransactionPlannerRequest_PositionClose) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionPlannerRequest_PositionClose.Merge(m, src) +} +func (m *TransactionPlannerRequest_PositionClose) XXX_Size() int { + return m.Size() +} +func (m *TransactionPlannerRequest_PositionClose) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionPlannerRequest_PositionClose.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionPlannerRequest_PositionClose proto.InternalMessageInfo + +func (m *TransactionPlannerRequest_PositionClose) GetPositionId() *v1alpha19.PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +type TransactionPlannerRequest_PositionWithdraw struct { + // The position to withdraw. + PositionId *v1alpha19.PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // The position's final reserves. + Reserves *v1alpha19.Reserves `protobuf:"bytes,2,opt,name=reserves,proto3" json:"reserves,omitempty"` + // The trading pair of the position. + TradingPair *v1alpha19.TradingPair `protobuf:"bytes,3,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` +} + +func (m *TransactionPlannerRequest_PositionWithdraw) Reset() { + *m = TransactionPlannerRequest_PositionWithdraw{} +} +func (m *TransactionPlannerRequest_PositionWithdraw) String() string { + return proto.CompactTextString(m) +} +func (*TransactionPlannerRequest_PositionWithdraw) ProtoMessage() {} +func (*TransactionPlannerRequest_PositionWithdraw) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{4, 7} +} +func (m *TransactionPlannerRequest_PositionWithdraw) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TransactionPlannerRequest_PositionWithdraw) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TransactionPlannerRequest_PositionWithdraw.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 *TransactionPlannerRequest_PositionWithdraw) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionPlannerRequest_PositionWithdraw.Merge(m, src) +} +func (m *TransactionPlannerRequest_PositionWithdraw) XXX_Size() int { + return m.Size() +} +func (m *TransactionPlannerRequest_PositionWithdraw) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionPlannerRequest_PositionWithdraw.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionPlannerRequest_PositionWithdraw proto.InternalMessageInfo + +func (m *TransactionPlannerRequest_PositionWithdraw) GetPositionId() *v1alpha19.PositionId { + if m != nil { + return m.PositionId + } + return nil +} + +func (m *TransactionPlannerRequest_PositionWithdraw) GetReserves() *v1alpha19.Reserves { + if m != nil { + return m.Reserves + } + return nil +} + +func (m *TransactionPlannerRequest_PositionWithdraw) GetTradingPair() *v1alpha19.TradingPair { + if m != nil { + return m.TradingPair + } + return nil +} + type TransactionPlannerResponse struct { Plan *v1alpha1.TransactionPlan `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan,omitempty"` } @@ -703,8 +890,7 @@ func (m *TransactionPlannerResponse) GetPlan() *v1alpha1.TransactionPlan { } type AddressByIndexRequest struct { - AddressIndex *v1alpha11.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` - DisplayConfirm bool `protobuf:"varint,2,opt,name=display_confirm,json=displayConfirm,proto3" json:"display_confirm,omitempty"` + AddressIndex *v1alpha13.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` } func (m *AddressByIndexRequest) Reset() { *m = AddressByIndexRequest{} } @@ -740,22 +926,15 @@ func (m *AddressByIndexRequest) XXX_DiscardUnknown() { var xxx_messageInfo_AddressByIndexRequest proto.InternalMessageInfo -func (m *AddressByIndexRequest) GetAddressIndex() *v1alpha11.AddressIndex { +func (m *AddressByIndexRequest) GetAddressIndex() *v1alpha13.AddressIndex { if m != nil { return m.AddressIndex } return nil } -func (m *AddressByIndexRequest) GetDisplayConfirm() bool { - if m != nil { - return m.DisplayConfirm - } - return false -} - type AddressByIndexResponse struct { - Address *v1alpha11.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Address *v1alpha13.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` } func (m *AddressByIndexResponse) Reset() { *m = AddressByIndexResponse{} } @@ -791,22 +970,102 @@ func (m *AddressByIndexResponse) XXX_DiscardUnknown() { var xxx_messageInfo_AddressByIndexResponse proto.InternalMessageInfo -func (m *AddressByIndexResponse) GetAddress() *v1alpha11.Address { +func (m *AddressByIndexResponse) GetAddress() *v1alpha13.Address { if m != nil { return m.Address } return nil } +type WalletIdRequest struct { +} + +func (m *WalletIdRequest) Reset() { *m = WalletIdRequest{} } +func (m *WalletIdRequest) String() string { return proto.CompactTextString(m) } +func (*WalletIdRequest) ProtoMessage() {} +func (*WalletIdRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{8} +} +func (m *WalletIdRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WalletIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WalletIdRequest.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 *WalletIdRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_WalletIdRequest.Merge(m, src) +} +func (m *WalletIdRequest) XXX_Size() int { + return m.Size() +} +func (m *WalletIdRequest) XXX_DiscardUnknown() { + xxx_messageInfo_WalletIdRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_WalletIdRequest proto.InternalMessageInfo + +type WalletIdResponse struct { + WalletId *v1alpha13.WalletId `protobuf:"bytes,1,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` +} + +func (m *WalletIdResponse) Reset() { *m = WalletIdResponse{} } +func (m *WalletIdResponse) String() string { return proto.CompactTextString(m) } +func (*WalletIdResponse) ProtoMessage() {} +func (*WalletIdResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{9} +} +func (m *WalletIdResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WalletIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WalletIdResponse.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 *WalletIdResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_WalletIdResponse.Merge(m, src) +} +func (m *WalletIdResponse) XXX_Size() int { + return m.Size() +} +func (m *WalletIdResponse) XXX_DiscardUnknown() { + xxx_messageInfo_WalletIdResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_WalletIdResponse proto.InternalMessageInfo + +func (m *WalletIdResponse) GetWalletId() *v1alpha13.WalletId { + if m != nil { + return m.WalletId + } + return nil +} + type IndexByAddressRequest struct { - Address *v1alpha11.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Address *v1alpha13.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` } func (m *IndexByAddressRequest) Reset() { *m = IndexByAddressRequest{} } func (m *IndexByAddressRequest) String() string { return proto.CompactTextString(m) } func (*IndexByAddressRequest) ProtoMessage() {} func (*IndexByAddressRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{8} + return fileDescriptor_0aa947b204e6a7c2, []int{10} } func (m *IndexByAddressRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -835,7 +1094,7 @@ func (m *IndexByAddressRequest) XXX_DiscardUnknown() { var xxx_messageInfo_IndexByAddressRequest proto.InternalMessageInfo -func (m *IndexByAddressRequest) GetAddress() *v1alpha11.Address { +func (m *IndexByAddressRequest) GetAddress() *v1alpha13.Address { if m != nil { return m.Address } @@ -843,16 +1102,15 @@ func (m *IndexByAddressRequest) GetAddress() *v1alpha11.Address { } type IndexByAddressResponse struct { - // Types that are valid to be assigned to XAddressIndex: - // *IndexByAddressResponse_AddressIndex - XAddressIndex isIndexByAddressResponse_XAddressIndex `protobuf_oneof:"_address_index"` + // Will be absent if given an address not viewable by this viewing service + AddressIndex *v1alpha13.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` } func (m *IndexByAddressResponse) Reset() { *m = IndexByAddressResponse{} } func (m *IndexByAddressResponse) String() string { return proto.CompactTextString(m) } func (*IndexByAddressResponse) ProtoMessage() {} func (*IndexByAddressResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{9} + return fileDescriptor_0aa947b204e6a7c2, []int{11} } func (m *IndexByAddressResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -881,41 +1139,15 @@ func (m *IndexByAddressResponse) XXX_DiscardUnknown() { var xxx_messageInfo_IndexByAddressResponse proto.InternalMessageInfo -type isIndexByAddressResponse_XAddressIndex interface { - isIndexByAddressResponse_XAddressIndex() - MarshalTo([]byte) (int, error) - Size() int -} - -type IndexByAddressResponse_AddressIndex struct { - AddressIndex *v1alpha11.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3,oneof" json:"address_index,omitempty"` -} - -func (*IndexByAddressResponse_AddressIndex) isIndexByAddressResponse_XAddressIndex() {} - -func (m *IndexByAddressResponse) GetXAddressIndex() isIndexByAddressResponse_XAddressIndex { +func (m *IndexByAddressResponse) GetAddressIndex() *v1alpha13.AddressIndex { if m != nil { - return m.XAddressIndex - } - return nil -} - -func (m *IndexByAddressResponse) GetAddressIndex() *v1alpha11.AddressIndex { - if x, ok := m.GetXAddressIndex().(*IndexByAddressResponse_AddressIndex); ok { - return x.AddressIndex + return m.AddressIndex } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*IndexByAddressResponse) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*IndexByAddressResponse_AddressIndex)(nil), - } -} - type EphemeralAddressRequest struct { - AddressIndex *v1alpha11.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` + AddressIndex *v1alpha13.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` DisplayConfirm bool `protobuf:"varint,2,opt,name=display_confirm,json=displayConfirm,proto3" json:"display_confirm,omitempty"` } @@ -923,7 +1155,7 @@ func (m *EphemeralAddressRequest) Reset() { *m = EphemeralAddressRequest func (m *EphemeralAddressRequest) String() string { return proto.CompactTextString(m) } func (*EphemeralAddressRequest) ProtoMessage() {} func (*EphemeralAddressRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{10} + return fileDescriptor_0aa947b204e6a7c2, []int{12} } func (m *EphemeralAddressRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -952,7 +1184,7 @@ func (m *EphemeralAddressRequest) XXX_DiscardUnknown() { var xxx_messageInfo_EphemeralAddressRequest proto.InternalMessageInfo -func (m *EphemeralAddressRequest) GetAddressIndex() *v1alpha11.AddressIndex { +func (m *EphemeralAddressRequest) GetAddressIndex() *v1alpha13.AddressIndex { if m != nil { return m.AddressIndex } @@ -967,14 +1199,14 @@ func (m *EphemeralAddressRequest) GetDisplayConfirm() bool { } type EphemeralAddressResponse struct { - Address *v1alpha11.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Address *v1alpha13.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` } func (m *EphemeralAddressResponse) Reset() { *m = EphemeralAddressResponse{} } func (m *EphemeralAddressResponse) String() string { return proto.CompactTextString(m) } func (*EphemeralAddressResponse) ProtoMessage() {} func (*EphemeralAddressResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{11} + return fileDescriptor_0aa947b204e6a7c2, []int{13} } func (m *EphemeralAddressResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1003,7 +1235,7 @@ func (m *EphemeralAddressResponse) XXX_DiscardUnknown() { var xxx_messageInfo_EphemeralAddressResponse proto.InternalMessageInfo -func (m *EphemeralAddressResponse) GetAddress() *v1alpha11.Address { +func (m *EphemeralAddressResponse) GetAddress() *v1alpha13.Address { if m != nil { return m.Address } @@ -1012,16 +1244,16 @@ func (m *EphemeralAddressResponse) GetAddress() *v1alpha11.Address { type BalancesRequest struct { // If present, filter balances to only include the account specified by the `AddressIndex`. - AccountFilter *v1alpha11.AddressIndex `protobuf:"bytes,1,opt,name=account_filter,json=accountFilter,proto3" json:"account_filter,omitempty"` + AccountFilter *v1alpha13.AddressIndex `protobuf:"bytes,1,opt,name=account_filter,json=accountFilter,proto3" json:"account_filter,omitempty"` // If present, filter balances to only include the specified asset ID. - AssetIdFilter *v1alpha11.AssetId `protobuf:"bytes,2,opt,name=asset_id_filter,json=assetIdFilter,proto3" json:"asset_id_filter,omitempty"` + AssetIdFilter *v1alpha15.AssetId `protobuf:"bytes,2,opt,name=asset_id_filter,json=assetIdFilter,proto3" json:"asset_id_filter,omitempty"` } func (m *BalancesRequest) Reset() { *m = BalancesRequest{} } func (m *BalancesRequest) String() string { return proto.CompactTextString(m) } func (*BalancesRequest) ProtoMessage() {} func (*BalancesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{12} + return fileDescriptor_0aa947b204e6a7c2, []int{14} } func (m *BalancesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1050,14 +1282,14 @@ func (m *BalancesRequest) XXX_DiscardUnknown() { var xxx_messageInfo_BalancesRequest proto.InternalMessageInfo -func (m *BalancesRequest) GetAccountFilter() *v1alpha11.AddressIndex { +func (m *BalancesRequest) GetAccountFilter() *v1alpha13.AddressIndex { if m != nil { return m.AccountFilter } return nil } -func (m *BalancesRequest) GetAssetIdFilter() *v1alpha11.AssetId { +func (m *BalancesRequest) GetAssetIdFilter() *v1alpha15.AssetId { if m != nil { return m.AssetIdFilter } @@ -1065,15 +1297,15 @@ func (m *BalancesRequest) GetAssetIdFilter() *v1alpha11.AssetId { } type BalancesResponse struct { - Account *v1alpha11.AddressIndex `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"` - Balance *v1alpha11.Value `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance,omitempty"` + Account *v1alpha13.AddressIndex `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"` + Balance *v1alpha15.Value `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance,omitempty"` } func (m *BalancesResponse) Reset() { *m = BalancesResponse{} } func (m *BalancesResponse) String() string { return proto.CompactTextString(m) } func (*BalancesResponse) ProtoMessage() {} func (*BalancesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{13} + return fileDescriptor_0aa947b204e6a7c2, []int{15} } func (m *BalancesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1102,37 +1334,36 @@ func (m *BalancesResponse) XXX_DiscardUnknown() { var xxx_messageInfo_BalancesResponse proto.InternalMessageInfo -func (m *BalancesResponse) GetAccount() *v1alpha11.AddressIndex { +func (m *BalancesResponse) GetAccount() *v1alpha13.AddressIndex { if m != nil { return m.Account } return nil } -func (m *BalancesResponse) GetBalance() *v1alpha11.Value { +func (m *BalancesResponse) GetBalance() *v1alpha15.Value { if m != nil { return m.Balance } return nil } -// Scaffolding for bearer-token authentication for the ViewService. -type ViewAuthToken struct { - Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"` +// Requests sync status of the view service. +type StatusRequest struct { } -func (m *ViewAuthToken) Reset() { *m = ViewAuthToken{} } -func (m *ViewAuthToken) String() string { return proto.CompactTextString(m) } -func (*ViewAuthToken) ProtoMessage() {} -func (*ViewAuthToken) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{14} +func (m *StatusRequest) Reset() { *m = StatusRequest{} } +func (m *StatusRequest) String() string { return proto.CompactTextString(m) } +func (*StatusRequest) ProtoMessage() {} +func (*StatusRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{16} } -func (m *ViewAuthToken) XXX_Unmarshal(b []byte) error { +func (m *StatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ViewAuthToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *StatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ViewAuthToken.Marshal(b, m, deterministic) + return xxx_messageInfo_StatusRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1142,41 +1373,40 @@ func (m *ViewAuthToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error return b[:n], nil } } -func (m *ViewAuthToken) XXX_Merge(src proto.Message) { - xxx_messageInfo_ViewAuthToken.Merge(m, src) +func (m *StatusRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatusRequest.Merge(m, src) } -func (m *ViewAuthToken) XXX_Size() int { +func (m *StatusRequest) XXX_Size() int { return m.Size() } -func (m *ViewAuthToken) XXX_DiscardUnknown() { - xxx_messageInfo_ViewAuthToken.DiscardUnknown(m) +func (m *StatusRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StatusRequest.DiscardUnknown(m) } -var xxx_messageInfo_ViewAuthToken proto.InternalMessageInfo - -func (m *ViewAuthToken) GetInner() []byte { - if m != nil { - return m.Inner - } - return nil -} +var xxx_messageInfo_StatusRequest proto.InternalMessageInfo -type ViewAuthRequest struct { - Fvk *v1alpha11.FullViewingKey `protobuf:"bytes,1,opt,name=fvk,proto3" json:"fvk,omitempty"` +// Returns the status of the view service and whether it is synchronized with the chain state. +type StatusResponse struct { + // The height the view service has synchronized to so far when doing a full linear sync + FullSyncHeight uint64 `protobuf:"varint,1,opt,name=full_sync_height,json=fullSyncHeight,proto3" json:"full_sync_height,omitempty"` + // The height the view service has synchronized to so far when doing a partial sync + PartialSyncHeight uint64 `protobuf:"varint,2,opt,name=partial_sync_height,json=partialSyncHeight,proto3" json:"partial_sync_height,omitempty"` + // Whether the view service is catching up with the chain state + CatchingUp bool `protobuf:"varint,3,opt,name=catching_up,json=catchingUp,proto3" json:"catching_up,omitempty"` } -func (m *ViewAuthRequest) Reset() { *m = ViewAuthRequest{} } -func (m *ViewAuthRequest) String() string { return proto.CompactTextString(m) } -func (*ViewAuthRequest) ProtoMessage() {} -func (*ViewAuthRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{15} +func (m *StatusResponse) Reset() { *m = StatusResponse{} } +func (m *StatusResponse) String() string { return proto.CompactTextString(m) } +func (*StatusResponse) ProtoMessage() {} +func (*StatusResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{17} } -func (m *ViewAuthRequest) XXX_Unmarshal(b []byte) error { +func (m *StatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ViewAuthRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *StatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ViewAuthRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_StatusResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1186,188 +1416,30 @@ func (m *ViewAuthRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } -func (m *ViewAuthRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ViewAuthRequest.Merge(m, src) +func (m *StatusResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatusResponse.Merge(m, src) } -func (m *ViewAuthRequest) XXX_Size() int { +func (m *StatusResponse) XXX_Size() int { return m.Size() } -func (m *ViewAuthRequest) XXX_DiscardUnknown() { - xxx_messageInfo_ViewAuthRequest.DiscardUnknown(m) +func (m *StatusResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StatusResponse.DiscardUnknown(m) } -var xxx_messageInfo_ViewAuthRequest proto.InternalMessageInfo +var xxx_messageInfo_StatusResponse proto.InternalMessageInfo -func (m *ViewAuthRequest) GetFvk() *v1alpha11.FullViewingKey { +func (m *StatusResponse) GetFullSyncHeight() uint64 { if m != nil { - return m.Fvk + return m.FullSyncHeight } - return nil + return 0 } -type ViewAuthResponse struct { - Token *ViewAuthToken `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"` -} - -func (m *ViewAuthResponse) Reset() { *m = ViewAuthResponse{} } -func (m *ViewAuthResponse) String() string { return proto.CompactTextString(m) } -func (*ViewAuthResponse) ProtoMessage() {} -func (*ViewAuthResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{16} -} -func (m *ViewAuthResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ViewAuthResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ViewAuthResponse.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 *ViewAuthResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ViewAuthResponse.Merge(m, src) -} -func (m *ViewAuthResponse) XXX_Size() int { - return m.Size() -} -func (m *ViewAuthResponse) XXX_DiscardUnknown() { - xxx_messageInfo_ViewAuthResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_ViewAuthResponse proto.InternalMessageInfo - -func (m *ViewAuthResponse) GetToken() *ViewAuthToken { - if m != nil { - return m.Token - } - return nil -} - -// Requests sync status of the view service. -type StatusRequest struct { - // Types that are valid to be assigned to XAccountGroupId: - // *StatusRequest_AccountGroupId - XAccountGroupId isStatusRequest_XAccountGroupId `protobuf_oneof:"_account_group_id"` -} - -func (m *StatusRequest) Reset() { *m = StatusRequest{} } -func (m *StatusRequest) String() string { return proto.CompactTextString(m) } -func (*StatusRequest) ProtoMessage() {} -func (*StatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{17} -} -func (m *StatusRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StatusRequest.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 *StatusRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_StatusRequest.Merge(m, src) -} -func (m *StatusRequest) XXX_Size() int { - return m.Size() -} -func (m *StatusRequest) XXX_DiscardUnknown() { - xxx_messageInfo_StatusRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_StatusRequest proto.InternalMessageInfo - -type isStatusRequest_XAccountGroupId interface { - isStatusRequest_XAccountGroupId() - MarshalTo([]byte) (int, error) - Size() int -} - -type StatusRequest_AccountGroupId struct { - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,14,opt,name=account_group_id,json=accountGroupId,proto3,oneof" json:"account_group_id,omitempty"` -} - -func (*StatusRequest_AccountGroupId) isStatusRequest_XAccountGroupId() {} - -func (m *StatusRequest) GetXAccountGroupId() isStatusRequest_XAccountGroupId { - if m != nil { - return m.XAccountGroupId - } - return nil -} - -func (m *StatusRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if x, ok := m.GetXAccountGroupId().(*StatusRequest_AccountGroupId); ok { - return x.AccountGroupId - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*StatusRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*StatusRequest_AccountGroupId)(nil), - } -} - -// Returns the status of the view service and whether it is synchronized with the chain state. -type StatusResponse struct { - // The height the view service has synchronized to so far - SyncHeight uint64 `protobuf:"varint,1,opt,name=sync_height,json=syncHeight,proto3" json:"sync_height,omitempty"` - // Whether the view service is catching up with the chain state - CatchingUp bool `protobuf:"varint,2,opt,name=catching_up,json=catchingUp,proto3" json:"catching_up,omitempty"` -} - -func (m *StatusResponse) Reset() { *m = StatusResponse{} } -func (m *StatusResponse) String() string { return proto.CompactTextString(m) } -func (*StatusResponse) ProtoMessage() {} -func (*StatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{18} -} -func (m *StatusResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *StatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_StatusResponse.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 *StatusResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_StatusResponse.Merge(m, src) -} -func (m *StatusResponse) XXX_Size() int { - return m.Size() -} -func (m *StatusResponse) XXX_DiscardUnknown() { - xxx_messageInfo_StatusResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_StatusResponse proto.InternalMessageInfo - -func (m *StatusResponse) GetSyncHeight() uint64 { - if m != nil { - return m.SyncHeight - } - return 0 +func (m *StatusResponse) GetPartialSyncHeight() uint64 { + if m != nil { + return m.PartialSyncHeight + } + return 0 } func (m *StatusResponse) GetCatchingUp() bool { @@ -1379,16 +1451,13 @@ func (m *StatusResponse) GetCatchingUp() bool { // Requests streaming updates on the sync height until the view service is synchronized. type StatusStreamRequest struct { - // Types that are valid to be assigned to XAccountGroupId: - // *StatusStreamRequest_AccountGroupId - XAccountGroupId isStatusStreamRequest_XAccountGroupId `protobuf_oneof:"_account_group_id"` } func (m *StatusStreamRequest) Reset() { *m = StatusStreamRequest{} } func (m *StatusStreamRequest) String() string { return proto.CompactTextString(m) } func (*StatusStreamRequest) ProtoMessage() {} func (*StatusStreamRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{19} + return fileDescriptor_0aa947b204e6a7c2, []int{18} } func (m *StatusStreamRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1417,50 +1486,21 @@ func (m *StatusStreamRequest) XXX_DiscardUnknown() { var xxx_messageInfo_StatusStreamRequest proto.InternalMessageInfo -type isStatusStreamRequest_XAccountGroupId interface { - isStatusStreamRequest_XAccountGroupId() - MarshalTo([]byte) (int, error) - Size() int -} - -type StatusStreamRequest_AccountGroupId struct { - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,14,opt,name=account_group_id,json=accountGroupId,proto3,oneof" json:"account_group_id,omitempty"` -} - -func (*StatusStreamRequest_AccountGroupId) isStatusStreamRequest_XAccountGroupId() {} - -func (m *StatusStreamRequest) GetXAccountGroupId() isStatusStreamRequest_XAccountGroupId { - if m != nil { - return m.XAccountGroupId - } - return nil -} - -func (m *StatusStreamRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if x, ok := m.GetXAccountGroupId().(*StatusStreamRequest_AccountGroupId); ok { - return x.AccountGroupId - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*StatusStreamRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*StatusStreamRequest_AccountGroupId)(nil), - } -} - // A streaming sync status update type StatusStreamResponse struct { + // The latest known block height LatestKnownBlockHeight uint64 `protobuf:"varint,1,opt,name=latest_known_block_height,json=latestKnownBlockHeight,proto3" json:"latest_known_block_height,omitempty"` - SyncHeight uint64 `protobuf:"varint,2,opt,name=sync_height,json=syncHeight,proto3" json:"sync_height,omitempty"` + // The height the view service has synchronized to so far when doing a full linear sync + FullSyncHeight uint64 `protobuf:"varint,2,opt,name=full_sync_height,json=fullSyncHeight,proto3" json:"full_sync_height,omitempty"` + // The height the view service has synchronized to so far when doing a partial sync + PartialSyncHeight uint64 `protobuf:"varint,3,opt,name=partial_sync_height,json=partialSyncHeight,proto3" json:"partial_sync_height,omitempty"` } func (m *StatusStreamResponse) Reset() { *m = StatusStreamResponse{} } func (m *StatusStreamResponse) String() string { return proto.CompactTextString(m) } func (*StatusStreamResponse) ProtoMessage() {} func (*StatusStreamResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{20} + return fileDescriptor_0aa947b204e6a7c2, []int{19} } func (m *StatusStreamResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1496,9 +1536,16 @@ func (m *StatusStreamResponse) GetLatestKnownBlockHeight() uint64 { return 0 } -func (m *StatusStreamResponse) GetSyncHeight() uint64 { +func (m *StatusStreamResponse) GetFullSyncHeight() uint64 { + if m != nil { + return m.FullSyncHeight + } + return 0 +} + +func (m *StatusStreamResponse) GetPartialSyncHeight() uint64 { if m != nil { - return m.SyncHeight + return m.PartialSyncHeight } return 0 } @@ -1511,23 +1558,20 @@ type NotesRequest struct { // If set, return spent notes as well as unspent notes. IncludeSpent bool `protobuf:"varint,2,opt,name=include_spent,json=includeSpent,proto3" json:"include_spent,omitempty"` // If set, only return notes with the specified asset id. - AssetId *v1alpha11.AssetId `protobuf:"bytes,3,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` - // If set, only return notes with the specified address incore.dex.v1alpha1. - AddressIndex *v1alpha11.AddressIndex `protobuf:"bytes,4,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` + AssetId *v1alpha15.AssetId `protobuf:"bytes,3,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` + // If set, only return notes with the specified address incore.component.dex.v1alpha1. + AddressIndex *v1alpha13.AddressIndex `protobuf:"bytes,4,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` // If set, stop returning notes once the total exceeds this amount. // // Ignored if `asset_id` is unset or if `include_spent` is set. - AmountToSpend *v1alpha11.Amount `protobuf:"bytes,6,opt,name=amount_to_spend,json=amountToSpend,proto3" json:"amount_to_spend,omitempty"` - // Types that are valid to be assigned to XAccountGroupId: - // *NotesRequest_AccountGroupId - XAccountGroupId isNotesRequest_XAccountGroupId `protobuf_oneof:"_account_group_id"` + AmountToSpend *v1alpha17.Amount `protobuf:"bytes,6,opt,name=amount_to_spend,json=amountToSpend,proto3" json:"amount_to_spend,omitempty"` } func (m *NotesRequest) Reset() { *m = NotesRequest{} } func (m *NotesRequest) String() string { return proto.CompactTextString(m) } func (*NotesRequest) ProtoMessage() {} func (*NotesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{21} + return fileDescriptor_0aa947b204e6a7c2, []int{20} } func (m *NotesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1556,25 +1600,6 @@ func (m *NotesRequest) XXX_DiscardUnknown() { var xxx_messageInfo_NotesRequest proto.InternalMessageInfo -type isNotesRequest_XAccountGroupId interface { - isNotesRequest_XAccountGroupId() - MarshalTo([]byte) (int, error) - Size() int -} - -type NotesRequest_AccountGroupId struct { - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,14,opt,name=account_group_id,json=accountGroupId,proto3,oneof" json:"account_group_id,omitempty"` -} - -func (*NotesRequest_AccountGroupId) isNotesRequest_XAccountGroupId() {} - -func (m *NotesRequest) GetXAccountGroupId() isNotesRequest_XAccountGroupId { - if m != nil { - return m.XAccountGroupId - } - return nil -} - func (m *NotesRequest) GetIncludeSpent() bool { if m != nil { return m.IncludeSpent @@ -1582,57 +1607,40 @@ func (m *NotesRequest) GetIncludeSpent() bool { return false } -func (m *NotesRequest) GetAssetId() *v1alpha11.AssetId { +func (m *NotesRequest) GetAssetId() *v1alpha15.AssetId { if m != nil { return m.AssetId } return nil } -func (m *NotesRequest) GetAddressIndex() *v1alpha11.AddressIndex { +func (m *NotesRequest) GetAddressIndex() *v1alpha13.AddressIndex { if m != nil { return m.AddressIndex } return nil } -func (m *NotesRequest) GetAmountToSpend() *v1alpha11.Amount { +func (m *NotesRequest) GetAmountToSpend() *v1alpha17.Amount { if m != nil { return m.AmountToSpend } return nil } -func (m *NotesRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if x, ok := m.GetXAccountGroupId().(*NotesRequest_AccountGroupId); ok { - return x.AccountGroupId - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*NotesRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*NotesRequest_AccountGroupId)(nil), - } -} - // A query for notes to be used for voting on a proposal. type NotesForVotingRequest struct { // The starting height of the proposal. VotableAtHeight uint64 `protobuf:"varint,1,opt,name=votable_at_height,json=votableAtHeight,proto3" json:"votable_at_height,omitempty"` // If set, only return notes with the specified asset id. - AddressIndex *v1alpha11.AddressIndex `protobuf:"bytes,3,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` - // Types that are valid to be assigned to XAccountGroupId: - // *NotesForVotingRequest_AccountGroupId - XAccountGroupId isNotesForVotingRequest_XAccountGroupId `protobuf_oneof:"_account_group_id"` + AddressIndex *v1alpha13.AddressIndex `protobuf:"bytes,3,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` } func (m *NotesForVotingRequest) Reset() { *m = NotesForVotingRequest{} } func (m *NotesForVotingRequest) String() string { return proto.CompactTextString(m) } func (*NotesForVotingRequest) ProtoMessage() {} func (*NotesForVotingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{22} + return fileDescriptor_0aa947b204e6a7c2, []int{21} } func (m *NotesForVotingRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1661,25 +1669,6 @@ func (m *NotesForVotingRequest) XXX_DiscardUnknown() { var xxx_messageInfo_NotesForVotingRequest proto.InternalMessageInfo -type isNotesForVotingRequest_XAccountGroupId interface { - isNotesForVotingRequest_XAccountGroupId() - MarshalTo([]byte) (int, error) - Size() int -} - -type NotesForVotingRequest_AccountGroupId struct { - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,14,opt,name=account_group_id,json=accountGroupId,proto3,oneof" json:"account_group_id,omitempty"` -} - -func (*NotesForVotingRequest_AccountGroupId) isNotesForVotingRequest_XAccountGroupId() {} - -func (m *NotesForVotingRequest) GetXAccountGroupId() isNotesForVotingRequest_XAccountGroupId { - if m != nil { - return m.XAccountGroupId - } - return nil -} - func (m *NotesForVotingRequest) GetVotableAtHeight() uint64 { if m != nil { return m.VotableAtHeight @@ -1687,42 +1676,25 @@ func (m *NotesForVotingRequest) GetVotableAtHeight() uint64 { return 0 } -func (m *NotesForVotingRequest) GetAddressIndex() *v1alpha11.AddressIndex { +func (m *NotesForVotingRequest) GetAddressIndex() *v1alpha13.AddressIndex { if m != nil { return m.AddressIndex } return nil } -func (m *NotesForVotingRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if x, ok := m.GetXAccountGroupId().(*NotesForVotingRequest_AccountGroupId); ok { - return x.AccountGroupId - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*NotesForVotingRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*NotesForVotingRequest_AccountGroupId)(nil), - } -} - type WitnessRequest struct { // The note commitments to obtain auth paths for. - NoteCommitments []*v1alpha11.StateCommitment `protobuf:"bytes,2,rep,name=note_commitments,json=noteCommitments,proto3" json:"note_commitments,omitempty"` + NoteCommitments []*v1alpha16.StateCommitment `protobuf:"bytes,2,rep,name=note_commitments,json=noteCommitments,proto3" json:"note_commitments,omitempty"` // The transaction plan to witness TransactionPlan *v1alpha1.TransactionPlan `protobuf:"bytes,3,opt,name=transaction_plan,json=transactionPlan,proto3" json:"transaction_plan,omitempty"` - // Types that are valid to be assigned to XAccountGroupId: - // *WitnessRequest_AccountGroupId - XAccountGroupId isWitnessRequest_XAccountGroupId `protobuf_oneof:"_account_group_id"` } func (m *WitnessRequest) Reset() { *m = WitnessRequest{} } func (m *WitnessRequest) String() string { return proto.CompactTextString(m) } func (*WitnessRequest) ProtoMessage() {} func (*WitnessRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{23} + return fileDescriptor_0aa947b204e6a7c2, []int{22} } func (m *WitnessRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1751,26 +1723,7 @@ func (m *WitnessRequest) XXX_DiscardUnknown() { var xxx_messageInfo_WitnessRequest proto.InternalMessageInfo -type isWitnessRequest_XAccountGroupId interface { - isWitnessRequest_XAccountGroupId() - MarshalTo([]byte) (int, error) - Size() int -} - -type WitnessRequest_AccountGroupId struct { - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,14,opt,name=account_group_id,json=accountGroupId,proto3,oneof" json:"account_group_id,omitempty"` -} - -func (*WitnessRequest_AccountGroupId) isWitnessRequest_XAccountGroupId() {} - -func (m *WitnessRequest) GetXAccountGroupId() isWitnessRequest_XAccountGroupId { - if m != nil { - return m.XAccountGroupId - } - return nil -} - -func (m *WitnessRequest) GetNoteCommitments() []*v1alpha11.StateCommitment { +func (m *WitnessRequest) GetNoteCommitments() []*v1alpha16.StateCommitment { if m != nil { return m.NoteCommitments } @@ -1784,20 +1737,6 @@ func (m *WitnessRequest) GetTransactionPlan() *v1alpha1.TransactionPlan { return nil } -func (m *WitnessRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if x, ok := m.GetXAccountGroupId().(*WitnessRequest_AccountGroupId); ok { - return x.AccountGroupId - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*WitnessRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*WitnessRequest_AccountGroupId)(nil), - } -} - type WitnessResponse struct { WitnessData *v1alpha1.WitnessData `protobuf:"bytes,1,opt,name=witness_data,json=witnessData,proto3" json:"witness_data,omitempty"` } @@ -1806,7 +1745,7 @@ func (m *WitnessResponse) Reset() { *m = WitnessResponse{} } func (m *WitnessResponse) String() string { return proto.CompactTextString(m) } func (*WitnessResponse) ProtoMessage() {} func (*WitnessResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{24} + return fileDescriptor_0aa947b204e6a7c2, []int{23} } func (m *WitnessResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1851,7 +1790,7 @@ func (m *WitnessAndBuildRequest) Reset() { *m = WitnessAndBuildRequest{} func (m *WitnessAndBuildRequest) String() string { return proto.CompactTextString(m) } func (*WitnessAndBuildRequest) ProtoMessage() {} func (*WitnessAndBuildRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{25} + return fileDescriptor_0aa947b204e6a7c2, []int{24} } func (m *WitnessAndBuildRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1902,7 +1841,7 @@ func (m *WitnessAndBuildResponse) Reset() { *m = WitnessAndBuildResponse func (m *WitnessAndBuildResponse) String() string { return proto.CompactTextString(m) } func (*WitnessAndBuildResponse) ProtoMessage() {} func (*WitnessAndBuildResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{26} + return fileDescriptor_0aa947b204e6a7c2, []int{25} } func (m *WitnessAndBuildResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1944,7 +1883,7 @@ type AssetsRequest struct { // the request indicate a filter. Filtered bool `protobuf:"varint,1,opt,name=filtered,proto3" json:"filtered,omitempty"` // Include these specific denominations in the response. - IncludeSpecificDenominations []*v1alpha11.Denom `protobuf:"bytes,2,rep,name=include_specific_denominations,json=includeSpecificDenominations,proto3" json:"include_specific_denominations,omitempty"` + IncludeSpecificDenominations []*v1alpha15.Denom `protobuf:"bytes,2,rep,name=include_specific_denominations,json=includeSpecificDenominations,proto3" json:"include_specific_denominations,omitempty"` // Include all delegation tokens, to any validator, in the response. IncludeDelegationTokens bool `protobuf:"varint,3,opt,name=include_delegation_tokens,json=includeDelegationTokens,proto3" json:"include_delegation_tokens,omitempty"` // Include all unbonding tokens, from any validator, in the response. @@ -1961,7 +1900,7 @@ func (m *AssetsRequest) Reset() { *m = AssetsRequest{} } func (m *AssetsRequest) String() string { return proto.CompactTextString(m) } func (*AssetsRequest) ProtoMessage() {} func (*AssetsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{27} + return fileDescriptor_0aa947b204e6a7c2, []int{26} } func (m *AssetsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1997,7 +1936,7 @@ func (m *AssetsRequest) GetFiltered() bool { return false } -func (m *AssetsRequest) GetIncludeSpecificDenominations() []*v1alpha11.Denom { +func (m *AssetsRequest) GetIncludeSpecificDenominations() []*v1alpha15.Denom { if m != nil { return m.IncludeSpecificDenominations } @@ -2041,14 +1980,14 @@ func (m *AssetsRequest) GetIncludeVotingReceiptTokens() bool { // Requests all assets known to the view service. type AssetsResponse struct { - DenomMetadata *v1alpha11.DenomMetadata `protobuf:"bytes,2,opt,name=denom_metadata,json=denomMetadata,proto3" json:"denom_metadata,omitempty"` + DenomMetadata *v1alpha15.DenomMetadata `protobuf:"bytes,2,opt,name=denom_metadata,json=denomMetadata,proto3" json:"denom_metadata,omitempty"` } func (m *AssetsResponse) Reset() { *m = AssetsResponse{} } func (m *AssetsResponse) String() string { return proto.CompactTextString(m) } func (*AssetsResponse) ProtoMessage() {} func (*AssetsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{28} + return fileDescriptor_0aa947b204e6a7c2, []int{27} } func (m *AssetsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2077,29 +2016,29 @@ func (m *AssetsResponse) XXX_DiscardUnknown() { var xxx_messageInfo_AssetsResponse proto.InternalMessageInfo -func (m *AssetsResponse) GetDenomMetadata() *v1alpha11.DenomMetadata { +func (m *AssetsResponse) GetDenomMetadata() *v1alpha15.DenomMetadata { if m != nil { return m.DenomMetadata } return nil } -// Requests the current chain parameters from the view service. -type ChainParametersRequest struct { +// Requests the current app parameters from the view service. +type AppParametersRequest struct { } -func (m *ChainParametersRequest) Reset() { *m = ChainParametersRequest{} } -func (m *ChainParametersRequest) String() string { return proto.CompactTextString(m) } -func (*ChainParametersRequest) ProtoMessage() {} -func (*ChainParametersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{29} +func (m *AppParametersRequest) Reset() { *m = AppParametersRequest{} } +func (m *AppParametersRequest) String() string { return proto.CompactTextString(m) } +func (*AppParametersRequest) ProtoMessage() {} +func (*AppParametersRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{28} } -func (m *ChainParametersRequest) XXX_Unmarshal(b []byte) error { +func (m *AppParametersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ChainParametersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *AppParametersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ChainParametersRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_AppParametersRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2109,34 +2048,34 @@ func (m *ChainParametersRequest) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } -func (m *ChainParametersRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ChainParametersRequest.Merge(m, src) +func (m *AppParametersRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppParametersRequest.Merge(m, src) } -func (m *ChainParametersRequest) XXX_Size() int { +func (m *AppParametersRequest) XXX_Size() int { return m.Size() } -func (m *ChainParametersRequest) XXX_DiscardUnknown() { - xxx_messageInfo_ChainParametersRequest.DiscardUnknown(m) +func (m *AppParametersRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AppParametersRequest.DiscardUnknown(m) } -var xxx_messageInfo_ChainParametersRequest proto.InternalMessageInfo +var xxx_messageInfo_AppParametersRequest proto.InternalMessageInfo -type ChainParametersResponse struct { - Parameters *v1alpha14.ChainParameters `protobuf:"bytes,1,opt,name=parameters,proto3" json:"parameters,omitempty"` +type AppParametersResponse struct { + Parameters *v1alpha110.AppParameters `protobuf:"bytes,1,opt,name=parameters,proto3" json:"parameters,omitempty"` } -func (m *ChainParametersResponse) Reset() { *m = ChainParametersResponse{} } -func (m *ChainParametersResponse) String() string { return proto.CompactTextString(m) } -func (*ChainParametersResponse) ProtoMessage() {} -func (*ChainParametersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{30} +func (m *AppParametersResponse) Reset() { *m = AppParametersResponse{} } +func (m *AppParametersResponse) String() string { return proto.CompactTextString(m) } +func (*AppParametersResponse) ProtoMessage() {} +func (*AppParametersResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{29} } -func (m *ChainParametersResponse) XXX_Unmarshal(b []byte) error { +func (m *AppParametersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ChainParametersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *AppParametersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ChainParametersResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_AppParametersResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2146,41 +2085,41 @@ func (m *ChainParametersResponse) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } -func (m *ChainParametersResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ChainParametersResponse.Merge(m, src) +func (m *AppParametersResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppParametersResponse.Merge(m, src) } -func (m *ChainParametersResponse) XXX_Size() int { +func (m *AppParametersResponse) XXX_Size() int { return m.Size() } -func (m *ChainParametersResponse) XXX_DiscardUnknown() { - xxx_messageInfo_ChainParametersResponse.DiscardUnknown(m) +func (m *AppParametersResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AppParametersResponse.DiscardUnknown(m) } -var xxx_messageInfo_ChainParametersResponse proto.InternalMessageInfo +var xxx_messageInfo_AppParametersResponse proto.InternalMessageInfo -func (m *ChainParametersResponse) GetParameters() *v1alpha14.ChainParameters { +func (m *AppParametersResponse) GetParameters() *v1alpha110.AppParameters { if m != nil { return m.Parameters } return nil } -// Requests the current FMD parameters from the view service. -type FMDParametersRequest struct { +// Requests the current gas prices from the view service. +type GasPricesRequest struct { } -func (m *FMDParametersRequest) Reset() { *m = FMDParametersRequest{} } -func (m *FMDParametersRequest) String() string { return proto.CompactTextString(m) } -func (*FMDParametersRequest) ProtoMessage() {} -func (*FMDParametersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{31} +func (m *GasPricesRequest) Reset() { *m = GasPricesRequest{} } +func (m *GasPricesRequest) String() string { return proto.CompactTextString(m) } +func (*GasPricesRequest) ProtoMessage() {} +func (*GasPricesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{30} } -func (m *FMDParametersRequest) XXX_Unmarshal(b []byte) error { +func (m *GasPricesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *FMDParametersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GasPricesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_FMDParametersRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_GasPricesRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2190,34 +2129,34 @@ func (m *FMDParametersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } -func (m *FMDParametersRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_FMDParametersRequest.Merge(m, src) +func (m *GasPricesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GasPricesRequest.Merge(m, src) } -func (m *FMDParametersRequest) XXX_Size() int { +func (m *GasPricesRequest) XXX_Size() int { return m.Size() } -func (m *FMDParametersRequest) XXX_DiscardUnknown() { - xxx_messageInfo_FMDParametersRequest.DiscardUnknown(m) +func (m *GasPricesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GasPricesRequest.DiscardUnknown(m) } -var xxx_messageInfo_FMDParametersRequest proto.InternalMessageInfo +var xxx_messageInfo_GasPricesRequest proto.InternalMessageInfo -type FMDParametersResponse struct { - Parameters *v1alpha14.FmdParameters `protobuf:"bytes,1,opt,name=parameters,proto3" json:"parameters,omitempty"` +type GasPricesResponse struct { + GasPrices *v1alpha12.GasPrices `protobuf:"bytes,1,opt,name=gas_prices,json=gasPrices,proto3" json:"gas_prices,omitempty"` } -func (m *FMDParametersResponse) Reset() { *m = FMDParametersResponse{} } -func (m *FMDParametersResponse) String() string { return proto.CompactTextString(m) } -func (*FMDParametersResponse) ProtoMessage() {} -func (*FMDParametersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{32} +func (m *GasPricesResponse) Reset() { *m = GasPricesResponse{} } +func (m *GasPricesResponse) String() string { return proto.CompactTextString(m) } +func (*GasPricesResponse) ProtoMessage() {} +func (*GasPricesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{31} } -func (m *FMDParametersResponse) XXX_Unmarshal(b []byte) error { +func (m *GasPricesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *FMDParametersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GasPricesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_FMDParametersResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_GasPricesResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -2227,39 +2166,117 @@ func (m *FMDParametersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt return b[:n], nil } } -func (m *FMDParametersResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_FMDParametersResponse.Merge(m, src) +func (m *GasPricesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GasPricesResponse.Merge(m, src) } -func (m *FMDParametersResponse) XXX_Size() int { +func (m *GasPricesResponse) XXX_Size() int { return m.Size() } -func (m *FMDParametersResponse) XXX_DiscardUnknown() { - xxx_messageInfo_FMDParametersResponse.DiscardUnknown(m) +func (m *GasPricesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GasPricesResponse.DiscardUnknown(m) } -var xxx_messageInfo_FMDParametersResponse proto.InternalMessageInfo +var xxx_messageInfo_GasPricesResponse proto.InternalMessageInfo -func (m *FMDParametersResponse) GetParameters() *v1alpha14.FmdParameters { +func (m *GasPricesResponse) GetGasPrices() *v1alpha12.GasPrices { if m != nil { - return m.Parameters + return m.GasPrices } return nil } -type NoteByCommitmentRequest struct { - NoteCommitment *v1alpha11.StateCommitment `protobuf:"bytes,2,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` - // If set to true, waits to return until the requested note is detected. - AwaitDetection bool `protobuf:"varint,3,opt,name=await_detection,json=awaitDetection,proto3" json:"await_detection,omitempty"` - // Types that are valid to be assigned to XAccountGroupId: - // *NoteByCommitmentRequest_AccountGroupId - XAccountGroupId isNoteByCommitmentRequest_XAccountGroupId `protobuf_oneof:"_account_group_id"` +// Requests the current FMD parameters from the view service. +type FMDParametersRequest struct { +} + +func (m *FMDParametersRequest) Reset() { *m = FMDParametersRequest{} } +func (m *FMDParametersRequest) String() string { return proto.CompactTextString(m) } +func (*FMDParametersRequest) ProtoMessage() {} +func (*FMDParametersRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{32} +} +func (m *FMDParametersRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FMDParametersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FMDParametersRequest.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 *FMDParametersRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_FMDParametersRequest.Merge(m, src) +} +func (m *FMDParametersRequest) XXX_Size() int { + return m.Size() +} +func (m *FMDParametersRequest) XXX_DiscardUnknown() { + xxx_messageInfo_FMDParametersRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_FMDParametersRequest proto.InternalMessageInfo + +type FMDParametersResponse struct { + Parameters *v1alpha111.FmdParameters `protobuf:"bytes,1,opt,name=parameters,proto3" json:"parameters,omitempty"` +} + +func (m *FMDParametersResponse) Reset() { *m = FMDParametersResponse{} } +func (m *FMDParametersResponse) String() string { return proto.CompactTextString(m) } +func (*FMDParametersResponse) ProtoMessage() {} +func (*FMDParametersResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{33} +} +func (m *FMDParametersResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FMDParametersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FMDParametersResponse.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 *FMDParametersResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_FMDParametersResponse.Merge(m, src) +} +func (m *FMDParametersResponse) XXX_Size() int { + return m.Size() +} +func (m *FMDParametersResponse) XXX_DiscardUnknown() { + xxx_messageInfo_FMDParametersResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_FMDParametersResponse proto.InternalMessageInfo + +func (m *FMDParametersResponse) GetParameters() *v1alpha111.FmdParameters { + if m != nil { + return m.Parameters + } + return nil +} + +type NoteByCommitmentRequest struct { + NoteCommitment *v1alpha16.StateCommitment `protobuf:"bytes,2,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` + // If set to true, waits to return until the requested note is detected. + AwaitDetection bool `protobuf:"varint,3,opt,name=await_detection,json=awaitDetection,proto3" json:"await_detection,omitempty"` } func (m *NoteByCommitmentRequest) Reset() { *m = NoteByCommitmentRequest{} } func (m *NoteByCommitmentRequest) String() string { return proto.CompactTextString(m) } func (*NoteByCommitmentRequest) ProtoMessage() {} func (*NoteByCommitmentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{33} + return fileDescriptor_0aa947b204e6a7c2, []int{34} } func (m *NoteByCommitmentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2288,26 +2305,7 @@ func (m *NoteByCommitmentRequest) XXX_DiscardUnknown() { var xxx_messageInfo_NoteByCommitmentRequest proto.InternalMessageInfo -type isNoteByCommitmentRequest_XAccountGroupId interface { - isNoteByCommitmentRequest_XAccountGroupId() - MarshalTo([]byte) (int, error) - Size() int -} - -type NoteByCommitmentRequest_AccountGroupId struct { - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,14,opt,name=account_group_id,json=accountGroupId,proto3,oneof" json:"account_group_id,omitempty"` -} - -func (*NoteByCommitmentRequest_AccountGroupId) isNoteByCommitmentRequest_XAccountGroupId() {} - -func (m *NoteByCommitmentRequest) GetXAccountGroupId() isNoteByCommitmentRequest_XAccountGroupId { - if m != nil { - return m.XAccountGroupId - } - return nil -} - -func (m *NoteByCommitmentRequest) GetNoteCommitment() *v1alpha11.StateCommitment { +func (m *NoteByCommitmentRequest) GetNoteCommitment() *v1alpha16.StateCommitment { if m != nil { return m.NoteCommitment } @@ -2321,20 +2319,6 @@ func (m *NoteByCommitmentRequest) GetAwaitDetection() bool { return false } -func (m *NoteByCommitmentRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if x, ok := m.GetXAccountGroupId().(*NoteByCommitmentRequest_AccountGroupId); ok { - return x.AccountGroupId - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*NoteByCommitmentRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*NoteByCommitmentRequest_AccountGroupId)(nil), - } -} - type NoteByCommitmentResponse struct { SpendableNote *SpendableNoteRecord `protobuf:"bytes,1,opt,name=spendable_note,json=spendableNote,proto3" json:"spendable_note,omitempty"` } @@ -2343,7 +2327,7 @@ func (m *NoteByCommitmentResponse) Reset() { *m = NoteByCommitmentRespon func (m *NoteByCommitmentResponse) String() string { return proto.CompactTextString(m) } func (*NoteByCommitmentResponse) ProtoMessage() {} func (*NoteByCommitmentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{34} + return fileDescriptor_0aa947b204e6a7c2, []int{35} } func (m *NoteByCommitmentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2380,19 +2364,16 @@ func (m *NoteByCommitmentResponse) GetSpendableNote() *SpendableNoteRecord { } type SwapByCommitmentRequest struct { - SwapCommitment *v1alpha11.StateCommitment `protobuf:"bytes,2,opt,name=swap_commitment,json=swapCommitment,proto3" json:"swap_commitment,omitempty"` + SwapCommitment *v1alpha16.StateCommitment `protobuf:"bytes,2,opt,name=swap_commitment,json=swapCommitment,proto3" json:"swap_commitment,omitempty"` // If set to true, waits to return until the requested swap is detected. AwaitDetection bool `protobuf:"varint,3,opt,name=await_detection,json=awaitDetection,proto3" json:"await_detection,omitempty"` - // Types that are valid to be assigned to XAccountGroupId: - // *SwapByCommitmentRequest_AccountGroupId - XAccountGroupId isSwapByCommitmentRequest_XAccountGroupId `protobuf_oneof:"_account_group_id"` } func (m *SwapByCommitmentRequest) Reset() { *m = SwapByCommitmentRequest{} } func (m *SwapByCommitmentRequest) String() string { return proto.CompactTextString(m) } func (*SwapByCommitmentRequest) ProtoMessage() {} func (*SwapByCommitmentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{35} + return fileDescriptor_0aa947b204e6a7c2, []int{36} } func (m *SwapByCommitmentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2421,26 +2402,7 @@ func (m *SwapByCommitmentRequest) XXX_DiscardUnknown() { var xxx_messageInfo_SwapByCommitmentRequest proto.InternalMessageInfo -type isSwapByCommitmentRequest_XAccountGroupId interface { - isSwapByCommitmentRequest_XAccountGroupId() - MarshalTo([]byte) (int, error) - Size() int -} - -type SwapByCommitmentRequest_AccountGroupId struct { - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,14,opt,name=account_group_id,json=accountGroupId,proto3,oneof" json:"account_group_id,omitempty"` -} - -func (*SwapByCommitmentRequest_AccountGroupId) isSwapByCommitmentRequest_XAccountGroupId() {} - -func (m *SwapByCommitmentRequest) GetXAccountGroupId() isSwapByCommitmentRequest_XAccountGroupId { - if m != nil { - return m.XAccountGroupId - } - return nil -} - -func (m *SwapByCommitmentRequest) GetSwapCommitment() *v1alpha11.StateCommitment { +func (m *SwapByCommitmentRequest) GetSwapCommitment() *v1alpha16.StateCommitment { if m != nil { return m.SwapCommitment } @@ -2454,20 +2416,6 @@ func (m *SwapByCommitmentRequest) GetAwaitDetection() bool { return false } -func (m *SwapByCommitmentRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if x, ok := m.GetXAccountGroupId().(*SwapByCommitmentRequest_AccountGroupId); ok { - return x.AccountGroupId - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*SwapByCommitmentRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*SwapByCommitmentRequest_AccountGroupId)(nil), - } -} - type SwapByCommitmentResponse struct { Swap *SwapRecord `protobuf:"bytes,1,opt,name=swap,proto3" json:"swap,omitempty"` } @@ -2476,7 +2424,7 @@ func (m *SwapByCommitmentResponse) Reset() { *m = SwapByCommitmentRespon func (m *SwapByCommitmentResponse) String() string { return proto.CompactTextString(m) } func (*SwapByCommitmentResponse) ProtoMessage() {} func (*SwapByCommitmentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{36} + return fileDescriptor_0aa947b204e6a7c2, []int{37} } func (m *SwapByCommitmentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2512,19 +2460,96 @@ func (m *SwapByCommitmentResponse) GetSwap() *SwapRecord { return nil } +type UnclaimedSwapsRequest struct { +} + +func (m *UnclaimedSwapsRequest) Reset() { *m = UnclaimedSwapsRequest{} } +func (m *UnclaimedSwapsRequest) String() string { return proto.CompactTextString(m) } +func (*UnclaimedSwapsRequest) ProtoMessage() {} +func (*UnclaimedSwapsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{38} +} +func (m *UnclaimedSwapsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UnclaimedSwapsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UnclaimedSwapsRequest.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 *UnclaimedSwapsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnclaimedSwapsRequest.Merge(m, src) +} +func (m *UnclaimedSwapsRequest) XXX_Size() int { + return m.Size() +} +func (m *UnclaimedSwapsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_UnclaimedSwapsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_UnclaimedSwapsRequest proto.InternalMessageInfo + +type UnclaimedSwapsResponse struct { + Swap *SwapRecord `protobuf:"bytes,1,opt,name=swap,proto3" json:"swap,omitempty"` +} + +func (m *UnclaimedSwapsResponse) Reset() { *m = UnclaimedSwapsResponse{} } +func (m *UnclaimedSwapsResponse) String() string { return proto.CompactTextString(m) } +func (*UnclaimedSwapsResponse) ProtoMessage() {} +func (*UnclaimedSwapsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0aa947b204e6a7c2, []int{39} +} +func (m *UnclaimedSwapsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UnclaimedSwapsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UnclaimedSwapsResponse.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 *UnclaimedSwapsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnclaimedSwapsResponse.Merge(m, src) +} +func (m *UnclaimedSwapsResponse) XXX_Size() int { + return m.Size() +} +func (m *UnclaimedSwapsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_UnclaimedSwapsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_UnclaimedSwapsResponse proto.InternalMessageInfo + +func (m *UnclaimedSwapsResponse) GetSwap() *SwapRecord { + if m != nil { + return m.Swap + } + return nil +} + type NullifierStatusRequest struct { - Nullifier *v1alpha11.Nullifier `protobuf:"bytes,2,opt,name=nullifier,proto3" json:"nullifier,omitempty"` - AwaitDetection bool `protobuf:"varint,3,opt,name=await_detection,json=awaitDetection,proto3" json:"await_detection,omitempty"` - // Types that are valid to be assigned to XAccountGroupId: - // *NullifierStatusRequest_AccountGroupId - XAccountGroupId isNullifierStatusRequest_XAccountGroupId `protobuf_oneof:"_account_group_id"` + Nullifier *v1alpha112.Nullifier `protobuf:"bytes,2,opt,name=nullifier,proto3" json:"nullifier,omitempty"` + AwaitDetection bool `protobuf:"varint,3,opt,name=await_detection,json=awaitDetection,proto3" json:"await_detection,omitempty"` } func (m *NullifierStatusRequest) Reset() { *m = NullifierStatusRequest{} } func (m *NullifierStatusRequest) String() string { return proto.CompactTextString(m) } func (*NullifierStatusRequest) ProtoMessage() {} func (*NullifierStatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{37} + return fileDescriptor_0aa947b204e6a7c2, []int{40} } func (m *NullifierStatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2553,26 +2578,7 @@ func (m *NullifierStatusRequest) XXX_DiscardUnknown() { var xxx_messageInfo_NullifierStatusRequest proto.InternalMessageInfo -type isNullifierStatusRequest_XAccountGroupId interface { - isNullifierStatusRequest_XAccountGroupId() - MarshalTo([]byte) (int, error) - Size() int -} - -type NullifierStatusRequest_AccountGroupId struct { - AccountGroupId *v1alpha11.AccountGroupId `protobuf:"bytes,14,opt,name=account_group_id,json=accountGroupId,proto3,oneof" json:"account_group_id,omitempty"` -} - -func (*NullifierStatusRequest_AccountGroupId) isNullifierStatusRequest_XAccountGroupId() {} - -func (m *NullifierStatusRequest) GetXAccountGroupId() isNullifierStatusRequest_XAccountGroupId { - if m != nil { - return m.XAccountGroupId - } - return nil -} - -func (m *NullifierStatusRequest) GetNullifier() *v1alpha11.Nullifier { +func (m *NullifierStatusRequest) GetNullifier() *v1alpha112.Nullifier { if m != nil { return m.Nullifier } @@ -2586,20 +2592,6 @@ func (m *NullifierStatusRequest) GetAwaitDetection() bool { return false } -func (m *NullifierStatusRequest) GetAccountGroupId() *v1alpha11.AccountGroupId { - if x, ok := m.GetXAccountGroupId().(*NullifierStatusRequest_AccountGroupId); ok { - return x.AccountGroupId - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*NullifierStatusRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*NullifierStatusRequest_AccountGroupId)(nil), - } -} - type NullifierStatusResponse struct { Spent bool `protobuf:"varint,1,opt,name=spent,proto3" json:"spent,omitempty"` } @@ -2608,7 +2600,7 @@ func (m *NullifierStatusResponse) Reset() { *m = NullifierStatusResponse func (m *NullifierStatusResponse) String() string { return proto.CompactTextString(m) } func (*NullifierStatusResponse) ProtoMessage() {} func (*NullifierStatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{38} + return fileDescriptor_0aa947b204e6a7c2, []int{41} } func (m *NullifierStatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2646,14 +2638,14 @@ func (m *NullifierStatusResponse) GetSpent() bool { type TransactionInfoByHashRequest struct { // The transaction hash to query for. - Id *v1alpha1.Id `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + Id *v1alpha11.TransactionId `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` } func (m *TransactionInfoByHashRequest) Reset() { *m = TransactionInfoByHashRequest{} } func (m *TransactionInfoByHashRequest) String() string { return proto.CompactTextString(m) } func (*TransactionInfoByHashRequest) ProtoMessage() {} func (*TransactionInfoByHashRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{39} + return fileDescriptor_0aa947b204e6a7c2, []int{42} } func (m *TransactionInfoByHashRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2682,7 +2674,7 @@ func (m *TransactionInfoByHashRequest) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionInfoByHashRequest proto.InternalMessageInfo -func (m *TransactionInfoByHashRequest) GetId() *v1alpha1.Id { +func (m *TransactionInfoByHashRequest) GetId() *v1alpha11.TransactionId { if m != nil { return m.Id } @@ -2690,19 +2682,17 @@ func (m *TransactionInfoByHashRequest) GetId() *v1alpha1.Id { } type TransactionInfoRequest struct { - // Types that are valid to be assigned to XStartHeight: - // *TransactionInfoRequest_StartHeight - XStartHeight isTransactionInfoRequest_XStartHeight `protobuf_oneof:"_start_height"` - // Types that are valid to be assigned to XEndHeight: - // *TransactionInfoRequest_EndHeight - XEndHeight isTransactionInfoRequest_XEndHeight `protobuf_oneof:"_end_height"` + // If present, return only transactions after this height. + StartHeight uint64 `protobuf:"varint,1,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` + // If present, return only transactions before this height. + EndHeight uint64 `protobuf:"varint,2,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"` } func (m *TransactionInfoRequest) Reset() { *m = TransactionInfoRequest{} } func (m *TransactionInfoRequest) String() string { return proto.CompactTextString(m) } func (*TransactionInfoRequest) ProtoMessage() {} func (*TransactionInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{40} + return fileDescriptor_0aa947b204e6a7c2, []int{43} } func (m *TransactionInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2731,68 +2721,25 @@ func (m *TransactionInfoRequest) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionInfoRequest proto.InternalMessageInfo -type isTransactionInfoRequest_XStartHeight interface { - isTransactionInfoRequest_XStartHeight() - MarshalTo([]byte) (int, error) - Size() int -} -type isTransactionInfoRequest_XEndHeight interface { - isTransactionInfoRequest_XEndHeight() - MarshalTo([]byte) (int, error) - Size() int -} - -type TransactionInfoRequest_StartHeight struct { - StartHeight uint64 `protobuf:"varint,1,opt,name=start_height,json=startHeight,proto3,oneof" json:"start_height,omitempty"` -} -type TransactionInfoRequest_EndHeight struct { - EndHeight uint64 `protobuf:"varint,2,opt,name=end_height,json=endHeight,proto3,oneof" json:"end_height,omitempty"` -} - -func (*TransactionInfoRequest_StartHeight) isTransactionInfoRequest_XStartHeight() {} -func (*TransactionInfoRequest_EndHeight) isTransactionInfoRequest_XEndHeight() {} - -func (m *TransactionInfoRequest) GetXStartHeight() isTransactionInfoRequest_XStartHeight { - if m != nil { - return m.XStartHeight - } - return nil -} -func (m *TransactionInfoRequest) GetXEndHeight() isTransactionInfoRequest_XEndHeight { - if m != nil { - return m.XEndHeight - } - return nil -} - func (m *TransactionInfoRequest) GetStartHeight() uint64 { - if x, ok := m.GetXStartHeight().(*TransactionInfoRequest_StartHeight); ok { - return x.StartHeight + if m != nil { + return m.StartHeight } return 0 } func (m *TransactionInfoRequest) GetEndHeight() uint64 { - if x, ok := m.GetXEndHeight().(*TransactionInfoRequest_EndHeight); ok { - return x.EndHeight + if m != nil { + return m.EndHeight } return 0 } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*TransactionInfoRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*TransactionInfoRequest_StartHeight)(nil), - (*TransactionInfoRequest_EndHeight)(nil), - } -} - type TransactionInfo struct { - // Types that are valid to be assigned to XHeight: - // *TransactionInfo_Height - XHeight isTransactionInfo_XHeight `protobuf_oneof:"_height"` + // The height the transaction was included in a block, if known. + Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` // The hash of the transaction. - Id *v1alpha1.Id `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + Id *v1alpha11.TransactionId `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` // The transaction data itself. Transaction *v1alpha1.Transaction `protobuf:"bytes,3,opt,name=transaction,proto3" json:"transaction,omitempty"` // The transaction perspective, as seen by this view server. @@ -2805,7 +2752,7 @@ func (m *TransactionInfo) Reset() { *m = TransactionInfo{} } func (m *TransactionInfo) String() string { return proto.CompactTextString(m) } func (*TransactionInfo) ProtoMessage() {} func (*TransactionInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{41} + return fileDescriptor_0aa947b204e6a7c2, []int{44} } func (m *TransactionInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2834,33 +2781,14 @@ func (m *TransactionInfo) XXX_DiscardUnknown() { var xxx_messageInfo_TransactionInfo proto.InternalMessageInfo -type isTransactionInfo_XHeight interface { - isTransactionInfo_XHeight() - MarshalTo([]byte) (int, error) - Size() int -} - -type TransactionInfo_Height struct { - Height uint64 `protobuf:"varint,1,opt,name=height,proto3,oneof" json:"height,omitempty"` -} - -func (*TransactionInfo_Height) isTransactionInfo_XHeight() {} - -func (m *TransactionInfo) GetXHeight() isTransactionInfo_XHeight { - if m != nil { - return m.XHeight - } - return nil -} - func (m *TransactionInfo) GetHeight() uint64 { - if x, ok := m.GetXHeight().(*TransactionInfo_Height); ok { - return x.Height + if m != nil { + return m.Height } return 0 } -func (m *TransactionInfo) GetId() *v1alpha1.Id { +func (m *TransactionInfo) GetId() *v1alpha11.TransactionId { if m != nil { return m.Id } @@ -2888,13 +2816,6 @@ func (m *TransactionInfo) GetView() *v1alpha1.TransactionView { return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*TransactionInfo) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*TransactionInfo_Height)(nil), - } -} - type TransactionInfoResponse struct { TxInfo *TransactionInfo `protobuf:"bytes,1,opt,name=tx_info,json=txInfo,proto3" json:"tx_info,omitempty"` } @@ -2903,7 +2824,7 @@ func (m *TransactionInfoResponse) Reset() { *m = TransactionInfoResponse func (m *TransactionInfoResponse) String() string { return proto.CompactTextString(m) } func (*TransactionInfoResponse) ProtoMessage() {} func (*TransactionInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{42} + return fileDescriptor_0aa947b204e6a7c2, []int{45} } func (m *TransactionInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2947,7 +2868,7 @@ func (m *TransactionInfoByHashResponse) Reset() { *m = TransactionInfoBy func (m *TransactionInfoByHashResponse) String() string { return proto.CompactTextString(m) } func (*TransactionInfoByHashResponse) ProtoMessage() {} func (*TransactionInfoByHashResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{43} + return fileDescriptor_0aa947b204e6a7c2, []int{46} } func (m *TransactionInfoByHashResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2991,7 +2912,7 @@ func (m *NotesResponse) Reset() { *m = NotesResponse{} } func (m *NotesResponse) String() string { return proto.CompactTextString(m) } func (*NotesResponse) ProtoMessage() {} func (*NotesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{44} + return fileDescriptor_0aa947b204e6a7c2, []int{47} } func (m *NotesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3029,14 +2950,14 @@ func (m *NotesResponse) GetNoteRecord() *SpendableNoteRecord { type NotesForVotingResponse struct { NoteRecord *SpendableNoteRecord `protobuf:"bytes,1,opt,name=note_record,json=noteRecord,proto3" json:"note_record,omitempty"` - IdentityKey *v1alpha11.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` + IdentityKey *v1alpha13.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` } func (m *NotesForVotingResponse) Reset() { *m = NotesForVotingResponse{} } func (m *NotesForVotingResponse) String() string { return proto.CompactTextString(m) } func (*NotesForVotingResponse) ProtoMessage() {} func (*NotesForVotingResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{45} + return fileDescriptor_0aa947b204e6a7c2, []int{48} } func (m *NotesForVotingResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3072,7 +2993,7 @@ func (m *NotesForVotingResponse) GetNoteRecord() *SpendableNoteRecord { return nil } -func (m *NotesForVotingResponse) GetIdentityKey() *v1alpha11.IdentityKey { +func (m *NotesForVotingResponse) GetIdentityKey() *v1alpha13.IdentityKey { if m != nil { return m.IdentityKey } @@ -3082,29 +3003,28 @@ func (m *NotesForVotingResponse) GetIdentityKey() *v1alpha11.IdentityKey { // A note plaintext with associated metadata about its status. type SpendableNoteRecord struct { // The note commitment, identifying the note. - NoteCommitment *v1alpha11.StateCommitment `protobuf:"bytes,1,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` + NoteCommitment *v1alpha16.StateCommitment `protobuf:"bytes,1,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` // The note plaintext itself. - Note *v1alpha11.Note `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` - // A precomputed decryption of the note's address incore.dex.v1alpha1. - AddressIndex *v1alpha11.AddressIndex `protobuf:"bytes,3,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` + Note *v1alpha113.Note `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` + // A precomputed decryption of the note's address incore.component.dex.v1alpha1. + AddressIndex *v1alpha13.AddressIndex `protobuf:"bytes,3,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` // The note's nullifier. - Nullifier *v1alpha11.Nullifier `protobuf:"bytes,4,opt,name=nullifier,proto3" json:"nullifier,omitempty"` + Nullifier *v1alpha112.Nullifier `protobuf:"bytes,4,opt,name=nullifier,proto3" json:"nullifier,omitempty"` // The height at which the note was created. HeightCreated uint64 `protobuf:"varint,5,opt,name=height_created,json=heightCreated,proto3" json:"height_created,omitempty"` - // Types that are valid to be assigned to XHeightSpent: - // *SpendableNoteRecord_HeightSpent - XHeightSpent isSpendableNoteRecord_XHeightSpent `protobuf_oneof:"_height_spent"` + // Records whether the note was spent (and if so, at what height). + HeightSpent uint64 `protobuf:"varint,6,opt,name=height_spent,json=heightSpent,proto3" json:"height_spent,omitempty"` // The note position. Position uint64 `protobuf:"varint,7,opt,name=position,proto3" json:"position,omitempty"` - // The source of the note (a tx hash or otherwise) - Source *v1alpha14.NoteSource `protobuf:"bytes,8,opt,name=source,proto3" json:"source,omitempty"` + // The source of the note + Source *v1alpha112.CommitmentSource `protobuf:"bytes,8,opt,name=source,proto3" json:"source,omitempty"` } func (m *SpendableNoteRecord) Reset() { *m = SpendableNoteRecord{} } func (m *SpendableNoteRecord) String() string { return proto.CompactTextString(m) } func (*SpendableNoteRecord) ProtoMessage() {} func (*SpendableNoteRecord) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{46} + return fileDescriptor_0aa947b204e6a7c2, []int{49} } func (m *SpendableNoteRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3133,47 +3053,28 @@ func (m *SpendableNoteRecord) XXX_DiscardUnknown() { var xxx_messageInfo_SpendableNoteRecord proto.InternalMessageInfo -type isSpendableNoteRecord_XHeightSpent interface { - isSpendableNoteRecord_XHeightSpent() - MarshalTo([]byte) (int, error) - Size() int -} - -type SpendableNoteRecord_HeightSpent struct { - HeightSpent uint64 `protobuf:"varint,6,opt,name=height_spent,json=heightSpent,proto3,oneof" json:"height_spent,omitempty"` -} - -func (*SpendableNoteRecord_HeightSpent) isSpendableNoteRecord_XHeightSpent() {} - -func (m *SpendableNoteRecord) GetXHeightSpent() isSpendableNoteRecord_XHeightSpent { +func (m *SpendableNoteRecord) GetNoteCommitment() *v1alpha16.StateCommitment { if m != nil { - return m.XHeightSpent + return m.NoteCommitment } return nil } -func (m *SpendableNoteRecord) GetNoteCommitment() *v1alpha11.StateCommitment { +func (m *SpendableNoteRecord) GetNote() *v1alpha113.Note { if m != nil { - return m.NoteCommitment + return m.Note } return nil } -func (m *SpendableNoteRecord) GetNote() *v1alpha11.Note { - if m != nil { - return m.Note - } - return nil -} - -func (m *SpendableNoteRecord) GetAddressIndex() *v1alpha11.AddressIndex { +func (m *SpendableNoteRecord) GetAddressIndex() *v1alpha13.AddressIndex { if m != nil { return m.AddressIndex } return nil } -func (m *SpendableNoteRecord) GetNullifier() *v1alpha11.Nullifier { +func (m *SpendableNoteRecord) GetNullifier() *v1alpha112.Nullifier { if m != nil { return m.Nullifier } @@ -3188,8 +3089,8 @@ func (m *SpendableNoteRecord) GetHeightCreated() uint64 { } func (m *SpendableNoteRecord) GetHeightSpent() uint64 { - if x, ok := m.GetXHeightSpent().(*SpendableNoteRecord_HeightSpent); ok { - return x.HeightSpent + if m != nil { + return m.HeightSpent } return 0 } @@ -3201,37 +3102,28 @@ func (m *SpendableNoteRecord) GetPosition() uint64 { return 0 } -func (m *SpendableNoteRecord) GetSource() *v1alpha14.NoteSource { +func (m *SpendableNoteRecord) GetSource() *v1alpha112.CommitmentSource { if m != nil { return m.Source } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*SpendableNoteRecord) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*SpendableNoteRecord_HeightSpent)(nil), - } -} - type SwapRecord struct { - SwapCommitment *v1alpha11.StateCommitment `protobuf:"bytes,1,opt,name=swap_commitment,json=swapCommitment,proto3" json:"swap_commitment,omitempty"` - Swap *v1alpha15.SwapPlaintext `protobuf:"bytes,2,opt,name=swap,proto3" json:"swap,omitempty"` + SwapCommitment *v1alpha16.StateCommitment `protobuf:"bytes,1,opt,name=swap_commitment,json=swapCommitment,proto3" json:"swap_commitment,omitempty"` + Swap *v1alpha19.SwapPlaintext `protobuf:"bytes,2,opt,name=swap,proto3" json:"swap,omitempty"` Position uint64 `protobuf:"varint,3,opt,name=position,proto3" json:"position,omitempty"` - Nullifier *v1alpha11.Nullifier `protobuf:"bytes,4,opt,name=nullifier,proto3" json:"nullifier,omitempty"` - OutputData *v1alpha15.BatchSwapOutputData `protobuf:"bytes,5,opt,name=output_data,json=outputData,proto3" json:"output_data,omitempty"` - // Types that are valid to be assigned to XHeightClaimed: - // *SwapRecord_HeightClaimed - XHeightClaimed isSwapRecord_XHeightClaimed `protobuf_oneof:"_height_claimed"` - Source *v1alpha14.NoteSource `protobuf:"bytes,7,opt,name=source,proto3" json:"source,omitempty"` + Nullifier *v1alpha112.Nullifier `protobuf:"bytes,4,opt,name=nullifier,proto3" json:"nullifier,omitempty"` + OutputData *v1alpha19.BatchSwapOutputData `protobuf:"bytes,5,opt,name=output_data,json=outputData,proto3" json:"output_data,omitempty"` + HeightClaimed uint64 `protobuf:"varint,6,opt,name=height_claimed,json=heightClaimed,proto3" json:"height_claimed,omitempty"` + Source *v1alpha112.CommitmentSource `protobuf:"bytes,7,opt,name=source,proto3" json:"source,omitempty"` } func (m *SwapRecord) Reset() { *m = SwapRecord{} } func (m *SwapRecord) String() string { return proto.CompactTextString(m) } func (*SwapRecord) ProtoMessage() {} func (*SwapRecord) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{47} + return fileDescriptor_0aa947b204e6a7c2, []int{50} } func (m *SwapRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3260,33 +3152,14 @@ func (m *SwapRecord) XXX_DiscardUnknown() { var xxx_messageInfo_SwapRecord proto.InternalMessageInfo -type isSwapRecord_XHeightClaimed interface { - isSwapRecord_XHeightClaimed() - MarshalTo([]byte) (int, error) - Size() int -} - -type SwapRecord_HeightClaimed struct { - HeightClaimed uint64 `protobuf:"varint,6,opt,name=height_claimed,json=heightClaimed,proto3,oneof" json:"height_claimed,omitempty"` -} - -func (*SwapRecord_HeightClaimed) isSwapRecord_XHeightClaimed() {} - -func (m *SwapRecord) GetXHeightClaimed() isSwapRecord_XHeightClaimed { - if m != nil { - return m.XHeightClaimed - } - return nil -} - -func (m *SwapRecord) GetSwapCommitment() *v1alpha11.StateCommitment { +func (m *SwapRecord) GetSwapCommitment() *v1alpha16.StateCommitment { if m != nil { return m.SwapCommitment } return nil } -func (m *SwapRecord) GetSwap() *v1alpha15.SwapPlaintext { +func (m *SwapRecord) GetSwap() *v1alpha19.SwapPlaintext { if m != nil { return m.Swap } @@ -3300,14 +3173,14 @@ func (m *SwapRecord) GetPosition() uint64 { return 0 } -func (m *SwapRecord) GetNullifier() *v1alpha11.Nullifier { +func (m *SwapRecord) GetNullifier() *v1alpha112.Nullifier { if m != nil { return m.Nullifier } return nil } -func (m *SwapRecord) GetOutputData() *v1alpha15.BatchSwapOutputData { +func (m *SwapRecord) GetOutputData() *v1alpha19.BatchSwapOutputData { if m != nil { return m.OutputData } @@ -3315,40 +3188,31 @@ func (m *SwapRecord) GetOutputData() *v1alpha15.BatchSwapOutputData { } func (m *SwapRecord) GetHeightClaimed() uint64 { - if x, ok := m.GetXHeightClaimed().(*SwapRecord_HeightClaimed); ok { - return x.HeightClaimed + if m != nil { + return m.HeightClaimed } return 0 } -func (m *SwapRecord) GetSource() *v1alpha14.NoteSource { +func (m *SwapRecord) GetSource() *v1alpha112.CommitmentSource { if m != nil { return m.Source } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*SwapRecord) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*SwapRecord_HeightClaimed)(nil), - } -} - type OwnedPositionIdsRequest struct { - // Types that are valid to be assigned to XPositionState: - // *OwnedPositionIdsRequest_PositionState - XPositionState isOwnedPositionIdsRequest_XPositionState `protobuf_oneof:"_position_state"` - // Types that are valid to be assigned to XTradingPair: - // *OwnedPositionIdsRequest_TradingPair - XTradingPair isOwnedPositionIdsRequest_XTradingPair `protobuf_oneof:"_trading_pair"` + // If present, return only positions with this position state. + PositionState *v1alpha19.PositionState `protobuf:"bytes,1,opt,name=position_state,json=positionState,proto3" json:"position_state,omitempty"` + // If present, return only positions for this trading pair. + TradingPair *v1alpha19.TradingPair `protobuf:"bytes,2,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"` } func (m *OwnedPositionIdsRequest) Reset() { *m = OwnedPositionIdsRequest{} } func (m *OwnedPositionIdsRequest) String() string { return proto.CompactTextString(m) } func (*OwnedPositionIdsRequest) ProtoMessage() {} func (*OwnedPositionIdsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{48} + return fileDescriptor_0aa947b204e6a7c2, []int{51} } func (m *OwnedPositionIdsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3377,71 +3241,29 @@ func (m *OwnedPositionIdsRequest) XXX_DiscardUnknown() { var xxx_messageInfo_OwnedPositionIdsRequest proto.InternalMessageInfo -type isOwnedPositionIdsRequest_XPositionState interface { - isOwnedPositionIdsRequest_XPositionState() - MarshalTo([]byte) (int, error) - Size() int -} -type isOwnedPositionIdsRequest_XTradingPair interface { - isOwnedPositionIdsRequest_XTradingPair() - MarshalTo([]byte) (int, error) - Size() int -} - -type OwnedPositionIdsRequest_PositionState struct { - PositionState *v1alpha15.PositionState `protobuf:"bytes,1,opt,name=position_state,json=positionState,proto3,oneof" json:"position_state,omitempty"` -} -type OwnedPositionIdsRequest_TradingPair struct { - TradingPair *v1alpha15.TradingPair `protobuf:"bytes,2,opt,name=trading_pair,json=tradingPair,proto3,oneof" json:"trading_pair,omitempty"` -} - -func (*OwnedPositionIdsRequest_PositionState) isOwnedPositionIdsRequest_XPositionState() {} -func (*OwnedPositionIdsRequest_TradingPair) isOwnedPositionIdsRequest_XTradingPair() {} - -func (m *OwnedPositionIdsRequest) GetXPositionState() isOwnedPositionIdsRequest_XPositionState { +func (m *OwnedPositionIdsRequest) GetPositionState() *v1alpha19.PositionState { if m != nil { - return m.XPositionState - } - return nil -} -func (m *OwnedPositionIdsRequest) GetXTradingPair() isOwnedPositionIdsRequest_XTradingPair { - if m != nil { - return m.XTradingPair - } - return nil -} - -func (m *OwnedPositionIdsRequest) GetPositionState() *v1alpha15.PositionState { - if x, ok := m.GetXPositionState().(*OwnedPositionIdsRequest_PositionState); ok { - return x.PositionState + return m.PositionState } return nil } -func (m *OwnedPositionIdsRequest) GetTradingPair() *v1alpha15.TradingPair { - if x, ok := m.GetXTradingPair().(*OwnedPositionIdsRequest_TradingPair); ok { - return x.TradingPair +func (m *OwnedPositionIdsRequest) GetTradingPair() *v1alpha19.TradingPair { + if m != nil { + return m.TradingPair } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*OwnedPositionIdsRequest) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*OwnedPositionIdsRequest_PositionState)(nil), - (*OwnedPositionIdsRequest_TradingPair)(nil), - } -} - type OwnedPositionIdsResponse struct { - PositionId *v1alpha15.PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + PositionId *v1alpha19.PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` } func (m *OwnedPositionIdsResponse) Reset() { *m = OwnedPositionIdsResponse{} } func (m *OwnedPositionIdsResponse) String() string { return proto.CompactTextString(m) } func (*OwnedPositionIdsResponse) ProtoMessage() {} func (*OwnedPositionIdsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0aa947b204e6a7c2, []int{49} + return fileDescriptor_0aa947b204e6a7c2, []int{52} } func (m *OwnedPositionIdsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3470,7 +3292,7 @@ func (m *OwnedPositionIdsResponse) XXX_DiscardUnknown() { var xxx_messageInfo_OwnedPositionIdsResponse proto.InternalMessageInfo -func (m *OwnedPositionIdsResponse) GetPositionId() *v1alpha15.PositionId { +func (m *OwnedPositionIdsResponse) GetPositionId() *v1alpha19.PositionId { if m != nil { return m.PositionId } @@ -3488,18 +3310,20 @@ func init() { proto.RegisterType((*TransactionPlannerRequest_SwapClaim)(nil), "penumbra.view.v1alpha1.TransactionPlannerRequest.SwapClaim") proto.RegisterType((*TransactionPlannerRequest_Delegate)(nil), "penumbra.view.v1alpha1.TransactionPlannerRequest.Delegate") proto.RegisterType((*TransactionPlannerRequest_Undelegate)(nil), "penumbra.view.v1alpha1.TransactionPlannerRequest.Undelegate") + proto.RegisterType((*TransactionPlannerRequest_PositionOpen)(nil), "penumbra.view.v1alpha1.TransactionPlannerRequest.PositionOpen") + proto.RegisterType((*TransactionPlannerRequest_PositionClose)(nil), "penumbra.view.v1alpha1.TransactionPlannerRequest.PositionClose") + proto.RegisterType((*TransactionPlannerRequest_PositionWithdraw)(nil), "penumbra.view.v1alpha1.TransactionPlannerRequest.PositionWithdraw") proto.RegisterType((*TransactionPlannerResponse)(nil), "penumbra.view.v1alpha1.TransactionPlannerResponse") proto.RegisterType((*AddressByIndexRequest)(nil), "penumbra.view.v1alpha1.AddressByIndexRequest") proto.RegisterType((*AddressByIndexResponse)(nil), "penumbra.view.v1alpha1.AddressByIndexResponse") + proto.RegisterType((*WalletIdRequest)(nil), "penumbra.view.v1alpha1.WalletIdRequest") + proto.RegisterType((*WalletIdResponse)(nil), "penumbra.view.v1alpha1.WalletIdResponse") proto.RegisterType((*IndexByAddressRequest)(nil), "penumbra.view.v1alpha1.IndexByAddressRequest") proto.RegisterType((*IndexByAddressResponse)(nil), "penumbra.view.v1alpha1.IndexByAddressResponse") proto.RegisterType((*EphemeralAddressRequest)(nil), "penumbra.view.v1alpha1.EphemeralAddressRequest") proto.RegisterType((*EphemeralAddressResponse)(nil), "penumbra.view.v1alpha1.EphemeralAddressResponse") proto.RegisterType((*BalancesRequest)(nil), "penumbra.view.v1alpha1.BalancesRequest") proto.RegisterType((*BalancesResponse)(nil), "penumbra.view.v1alpha1.BalancesResponse") - proto.RegisterType((*ViewAuthToken)(nil), "penumbra.view.v1alpha1.ViewAuthToken") - proto.RegisterType((*ViewAuthRequest)(nil), "penumbra.view.v1alpha1.ViewAuthRequest") - proto.RegisterType((*ViewAuthResponse)(nil), "penumbra.view.v1alpha1.ViewAuthResponse") proto.RegisterType((*StatusRequest)(nil), "penumbra.view.v1alpha1.StatusRequest") proto.RegisterType((*StatusResponse)(nil), "penumbra.view.v1alpha1.StatusResponse") proto.RegisterType((*StatusStreamRequest)(nil), "penumbra.view.v1alpha1.StatusStreamRequest") @@ -3512,14 +3336,18 @@ func init() { proto.RegisterType((*WitnessAndBuildResponse)(nil), "penumbra.view.v1alpha1.WitnessAndBuildResponse") proto.RegisterType((*AssetsRequest)(nil), "penumbra.view.v1alpha1.AssetsRequest") proto.RegisterType((*AssetsResponse)(nil), "penumbra.view.v1alpha1.AssetsResponse") - proto.RegisterType((*ChainParametersRequest)(nil), "penumbra.view.v1alpha1.ChainParametersRequest") - proto.RegisterType((*ChainParametersResponse)(nil), "penumbra.view.v1alpha1.ChainParametersResponse") + proto.RegisterType((*AppParametersRequest)(nil), "penumbra.view.v1alpha1.AppParametersRequest") + proto.RegisterType((*AppParametersResponse)(nil), "penumbra.view.v1alpha1.AppParametersResponse") + proto.RegisterType((*GasPricesRequest)(nil), "penumbra.view.v1alpha1.GasPricesRequest") + proto.RegisterType((*GasPricesResponse)(nil), "penumbra.view.v1alpha1.GasPricesResponse") proto.RegisterType((*FMDParametersRequest)(nil), "penumbra.view.v1alpha1.FMDParametersRequest") proto.RegisterType((*FMDParametersResponse)(nil), "penumbra.view.v1alpha1.FMDParametersResponse") proto.RegisterType((*NoteByCommitmentRequest)(nil), "penumbra.view.v1alpha1.NoteByCommitmentRequest") proto.RegisterType((*NoteByCommitmentResponse)(nil), "penumbra.view.v1alpha1.NoteByCommitmentResponse") proto.RegisterType((*SwapByCommitmentRequest)(nil), "penumbra.view.v1alpha1.SwapByCommitmentRequest") proto.RegisterType((*SwapByCommitmentResponse)(nil), "penumbra.view.v1alpha1.SwapByCommitmentResponse") + proto.RegisterType((*UnclaimedSwapsRequest)(nil), "penumbra.view.v1alpha1.UnclaimedSwapsRequest") + proto.RegisterType((*UnclaimedSwapsResponse)(nil), "penumbra.view.v1alpha1.UnclaimedSwapsResponse") proto.RegisterType((*NullifierStatusRequest)(nil), "penumbra.view.v1alpha1.NullifierStatusRequest") proto.RegisterType((*NullifierStatusResponse)(nil), "penumbra.view.v1alpha1.NullifierStatusResponse") proto.RegisterType((*TransactionInfoByHashRequest)(nil), "penumbra.view.v1alpha1.TransactionInfoByHashRequest") @@ -3538,195 +3366,211 @@ func init() { func init() { proto.RegisterFile("penumbra/view/v1alpha1/view.proto", fileDescriptor_0aa947b204e6a7c2) } var fileDescriptor_0aa947b204e6a7c2 = []byte{ - // 3002 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5b, 0xcd, 0x6f, 0x1b, 0xc7, - 0x15, 0xf7, 0x92, 0xfa, 0xf2, 0xa3, 0x48, 0xca, 0x63, 0x5b, 0xa2, 0x99, 0x44, 0x49, 0x37, 0xf1, - 0x47, 0x9c, 0x84, 0xb2, 0x15, 0x27, 0x4d, 0x95, 0xa4, 0x8d, 0x68, 0x45, 0x96, 0xe0, 0xd8, 0x56, - 0x57, 0xb6, 0xdc, 0xa4, 0x4a, 0x17, 0xa3, 0xdd, 0x91, 0xb4, 0x15, 0xb9, 0xbb, 0xd9, 0x1d, 0xea, - 0xa3, 0x3d, 0xa5, 0x08, 0x0a, 0x23, 0x40, 0x83, 0xa0, 0xe8, 0xa5, 0xd7, 0x1e, 0x8b, 0x5e, 0x73, - 0x2d, 0x0a, 0xf4, 0x52, 0xf4, 0x94, 0x63, 0x81, 0x02, 0x45, 0x60, 0xa3, 0x97, 0xf6, 0x5f, 0x28, - 0xd0, 0x62, 0xbe, 0x96, 0xbb, 0x4b, 0xae, 0x49, 0x4a, 0x32, 0x1c, 0xf4, 0x24, 0xce, 0xcc, 0x7b, - 0xbf, 0xf7, 0x31, 0x33, 0x6f, 0xde, 0xbc, 0x59, 0xc1, 0x77, 0x7c, 0xe2, 0xb6, 0x9a, 0x1b, 0x01, - 0x9e, 0xd9, 0x75, 0xc8, 0xde, 0xcc, 0xee, 0x55, 0xdc, 0xf0, 0xb7, 0xf1, 0x55, 0xde, 0xaa, 0xf9, - 0x81, 0x47, 0x3d, 0x34, 0xa9, 0x48, 0x6a, 0xbc, 0x53, 0x91, 0x54, 0x2f, 0x45, 0xac, 0x96, 0x17, - 0x90, 0x19, 0x6b, 0x1b, 0x3b, 0x6e, 0x1b, 0x80, 0x37, 0x05, 0x42, 0xf5, 0x72, 0x8a, 0x32, 0x38, - 0xf0, 0xa9, 0x17, 0x23, 0xe5, 0x6d, 0x49, 0xfb, 0x52, 0x92, 0xd6, 0x26, 0xfb, 0x6d, 0x42, 0x9b, - 0xec, 0x4b, 0xaa, 0x6b, 0x49, 0x2a, 0x1a, 0x60, 0x37, 0xc4, 0x16, 0x75, 0xbc, 0x98, 0x06, 0xb1, - 0xce, 0xee, 0xd8, 0xce, 0x86, 0xd5, 0xa6, 0x76, 0x36, 0x2c, 0x49, 0x95, 0xb2, 0x2b, 0xa4, 0x78, - 0x87, 0xb4, 0xe9, 0x78, 0x53, 0x50, 0xea, 0xdf, 0x68, 0x50, 0x99, 0x6f, 0xd1, 0x6d, 0x2f, 0x70, - 0x7e, 0x46, 0xe6, 0x5d, 0xbb, 0xde, 0x72, 0x1a, 0xb6, 0x41, 0x3e, 0x69, 0x91, 0x90, 0xa2, 0x9f, - 0xc0, 0x44, 0x4c, 0x03, 0xd3, 0x6f, 0x60, 0xb7, 0xa2, 0xbd, 0xa0, 0x5d, 0x2a, 0xcc, 0xbe, 0x5e, - 0x8b, 0x3c, 0xca, 0x24, 0xd4, 0xe2, 0x8a, 0x2a, 0x39, 0xb5, 0xbb, 0xed, 0xce, 0x95, 0x06, 0x76, - 0x8d, 0x32, 0x4d, 0x76, 0x20, 0x1b, 0x10, 0x96, 0xb2, 0x31, 0x97, 0x60, 0x63, 0x8a, 0x2b, 0x39, - 0x2e, 0xe1, 0x8d, 0x7e, 0x24, 0xcc, 0xc7, 0xb9, 0x17, 0x30, 0xc5, 0xc6, 0x29, 0x9c, 0xee, 0xd2, - 0x5d, 0x38, 0xd7, 0xc5, 0xc2, 0xd0, 0xf7, 0xdc, 0x90, 0xa0, 0x1f, 0x42, 0x21, 0x86, 0x2c, 0xad, - 0x9b, 0x19, 0xd0, 0x3a, 0x23, 0x8e, 0xa1, 0xff, 0x56, 0x83, 0x67, 0xea, 0x81, 0x87, 0x6d, 0x0b, - 0x87, 0x34, 0x4e, 0x25, 0xbd, 0x7a, 0xfc, 0x22, 0xd1, 0x45, 0x28, 0xe3, 0x3d, 0xec, 0x50, 0xd3, - 0x26, 0x94, 0x08, 0x58, 0xe6, 0xc5, 0x31, 0xa3, 0xc4, 0xbb, 0x17, 0x54, 0xaf, 0xfe, 0xa9, 0x06, - 0xcf, 0x76, 0xd7, 0x4d, 0xfa, 0xe3, 0x4d, 0xc8, 0x39, 0xb6, 0xd4, 0xe9, 0x42, 0x3f, 0x3a, 0x2d, - 0xdb, 0x46, 0xce, 0xb1, 0xd1, 0xcb, 0x30, 0x11, 0xc9, 0x36, 0xb7, 0x89, 0xb3, 0xb5, 0x4d, 0xb9, - 0x0a, 0x43, 0x46, 0x39, 0xea, 0x5f, 0xe2, 0xdd, 0xfa, 0x97, 0xe3, 0x70, 0x2e, 0xb5, 0x34, 0x5c, - 0x12, 0x28, 0xef, 0xbc, 0x08, 0x45, 0xb2, 0xef, 0x3b, 0xc1, 0x81, 0x42, 0xd1, 0x38, 0xca, 0xb8, - 0xe8, 0x14, 0x10, 0xe8, 0x1a, 0xe4, 0x37, 0x09, 0x91, 0x2b, 0x45, 0x4f, 0xa9, 0x29, 0xf7, 0x62, - 0xa4, 0xe1, 0x22, 0x21, 0x06, 0x23, 0x47, 0xef, 0xc3, 0x50, 0x93, 0x34, 0xbd, 0x4a, 0x9e, 0xb3, - 0x5d, 0xed, 0xc7, 0xba, 0x5b, 0xa4, 0xe9, 0xad, 0x34, 0xb0, 0xe3, 0x52, 0xb2, 0x4f, 0x0d, 0xce, - 0x8e, 0xd6, 0x61, 0x02, 0x5b, 0x96, 0xd7, 0x72, 0xa9, 0xb9, 0x15, 0x78, 0x2d, 0xdf, 0x74, 0xec, - 0x4a, 0x89, 0x43, 0xbe, 0xd6, 0x43, 0x93, 0x79, 0xc1, 0x76, 0x83, 0x71, 0x2d, 0xdb, 0x4b, 0x27, - 0x8c, 0x12, 0x4e, 0xf4, 0x3c, 0xd0, 0x34, 0x64, 0xc0, 0xa8, 0xd7, 0xa2, 0x7e, 0x8b, 0x86, 0x95, - 0x33, 0x2f, 0xe4, 0x2f, 0x15, 0x66, 0xdf, 0xaa, 0x75, 0x0f, 0x5e, 0xb5, 0x4c, 0x1f, 0xd6, 0xee, - 0x70, 0x00, 0x43, 0x01, 0xa1, 0x0f, 0x60, 0x38, 0xdc, 0xc3, 0x7e, 0x58, 0x99, 0xe6, 0x88, 0x6f, - 0x0e, 0x8e, 0xb8, 0xba, 0x87, 0x7d, 0x43, 0x80, 0xa0, 0x75, 0x28, 0xb0, 0x1f, 0xa6, 0xd5, 0xc0, - 0x4e, 0x33, 0xac, 0x3c, 0xcf, 0x31, 0xdf, 0x3e, 0x1c, 0xe6, 0x75, 0x86, 0x61, 0x40, 0xa8, 0x7e, - 0x72, 0x74, 0x9b, 0x34, 0xc8, 0x16, 0xdf, 0xbf, 0x61, 0xe5, 0x12, 0x47, 0x9f, 0x1b, 0x1c, 0x7d, - 0x41, 0x80, 0x10, 0x23, 0x0e, 0x87, 0x36, 0xa0, 0xd8, 0x72, 0xe3, 0xf8, 0xb3, 0x1c, 0xff, 0x9d, - 0xc1, 0xf1, 0xef, 0x29, 0x18, 0x62, 0x24, 0x21, 0xd1, 0x22, 0x14, 0x9c, 0x0d, 0xcb, 0x14, 0x5c, - 0x61, 0xe5, 0x1d, 0x2e, 0xe1, 0x7c, 0x6a, 0x69, 0xb0, 0x58, 0xdd, 0xde, 0x43, 0x1b, 0xd6, 0xbc, - 0xd8, 0x86, 0xe0, 0xa8, 0x9f, 0x61, 0xf5, 0x97, 0x1a, 0x8c, 0x88, 0x99, 0x44, 0x73, 0x30, 0xbc, - 0x8b, 0x1b, 0x2d, 0x22, 0x37, 0xe6, 0x4b, 0x3d, 0xd6, 0xd9, 0x1a, 0xa3, 0x35, 0x04, 0x0b, 0x7a, - 0x0f, 0x46, 0xb1, 0x6d, 0x07, 0x24, 0x0c, 0xe5, 0x7e, 0xb9, 0xd0, 0x6b, 0x95, 0x0a, 0x6a, 0x43, - 0xb1, 0x55, 0xff, 0xac, 0xc1, 0x10, 0x9b, 0xac, 0x23, 0xa9, 0xb1, 0x0c, 0xe3, 0x14, 0x07, 0x5b, - 0x84, 0x9a, 0x38, 0x0c, 0x09, 0xed, 0x57, 0x17, 0x46, 0xbb, 0x6c, 0x1b, 0x05, 0xc1, 0xcb, 0x9b, - 0x6a, 0xf7, 0xe7, 0x07, 0xda, 0xfd, 0x55, 0x1b, 0x4e, 0x46, 0x2b, 0x0e, 0xdd, 0x87, 0xb2, 0x58, - 0xc3, 0x5e, 0xb3, 0xe9, 0xd0, 0x26, 0x71, 0xa9, 0xb4, 0xa9, 0xd6, 0x03, 0x6e, 0x95, 0x62, 0x4a, - 0xae, 0x47, 0x5c, 0x46, 0x89, 0x2f, 0xdd, 0xa8, 0x5d, 0xfd, 0x42, 0x83, 0x31, 0xb5, 0xf4, 0xd0, - 0xbb, 0x30, 0x82, 0x9b, 0x6c, 0x7f, 0x4b, 0xf0, 0xf3, 0xbd, 0xac, 0xe5, 0xc4, 0x86, 0x64, 0x42, - 0xd7, 0xe1, 0x64, 0x80, 0x29, 0x11, 0xa7, 0x62, 0xbe, 0xab, 0xbf, 0xc4, 0x51, 0x1e, 0x01, 0x18, - 0x98, 0x12, 0x7e, 0x0c, 0x8e, 0x05, 0xf2, 0x57, 0xf5, 0x57, 0x1a, 0x40, 0x7b, 0xad, 0x1e, 0x69, - 0x0a, 0x13, 0xfa, 0xe4, 0x0e, 0xa7, 0x4f, 0xfd, 0x34, 0x9c, 0x32, 0xd3, 0xe1, 0x53, 0x27, 0x50, - 0xed, 0xb6, 0xd3, 0xe4, 0x99, 0x74, 0x03, 0x86, 0x8e, 0x9a, 0x7a, 0x70, 0x00, 0xfd, 0xd7, 0x1a, - 0x9c, 0x95, 0xab, 0xbb, 0x7e, 0xb0, 0xec, 0xda, 0x64, 0x5f, 0x9d, 0x3a, 0x2b, 0x50, 0x94, 0xab, - 0xdd, 0x74, 0x58, 0xbf, 0x94, 0xf5, 0x4a, 0x7f, 0x5b, 0x45, 0x40, 0x8d, 0xe3, 0x58, 0x8b, 0x1d, - 0xc9, 0xb6, 0x13, 0xfa, 0x0d, 0x7c, 0x60, 0x5a, 0x9e, 0xbb, 0xe9, 0x04, 0x4d, 0x75, 0x24, 0xcb, - 0xee, 0xeb, 0xa2, 0x57, 0xff, 0x08, 0x26, 0xd3, 0x3a, 0x49, 0xbb, 0x63, 0x3b, 0x57, 0x3b, 0xd4, - 0xce, 0xd5, 0x3f, 0x84, 0xb3, 0x1c, 0xb2, 0x7e, 0xa0, 0x86, 0xa4, 0xbd, 0x47, 0x87, 0xfe, 0x54, - 0x83, 0xc9, 0x34, 0xb6, 0xd4, 0xfb, 0xde, 0xd1, 0x9d, 0xb9, 0x74, 0x22, 0xe9, 0xce, 0x07, 0x9a, - 0x56, 0x9f, 0x80, 0x92, 0x99, 0xc0, 0xd5, 0x7f, 0xa3, 0xc1, 0xd4, 0xfb, 0xfe, 0x36, 0x69, 0x92, - 0x00, 0x37, 0x52, 0x16, 0x3e, 0xc5, 0x19, 0x5d, 0x87, 0x4a, 0xa7, 0x56, 0xc7, 0x36, 0xa7, 0x5f, - 0x69, 0x50, 0xae, 0xe3, 0x06, 0x76, 0x2d, 0x12, 0x19, 0x6b, 0x80, 0xca, 0x24, 0xcc, 0x4d, 0xa7, - 0x41, 0x49, 0x70, 0x18, 0x6b, 0x8b, 0x12, 0x62, 0x91, 0x23, 0xa0, 0xdb, 0x50, 0xe6, 0x91, 0xda, - 0x74, 0x6c, 0x05, 0x3a, 0x58, 0xcc, 0x2e, 0x62, 0xf1, 0x43, 0xe0, 0xb1, 0xb4, 0x78, 0xa2, 0xad, - 0xb7, 0x74, 0xc7, 0xfb, 0x30, 0x2a, 0xa5, 0x1e, 0x46, 0x63, 0xc5, 0x8b, 0xbe, 0x0f, 0xa3, 0x1b, - 0x02, 0x5a, 0xea, 0xd8, 0x5f, 0x5c, 0x53, 0x4c, 0xfa, 0x79, 0x28, 0xae, 0x39, 0x64, 0x8f, 0x5d, - 0x13, 0xee, 0x7a, 0x3b, 0xc4, 0x45, 0x67, 0x60, 0xd8, 0x61, 0x31, 0x88, 0x6b, 0x35, 0x6e, 0x88, - 0x86, 0x6e, 0x40, 0x59, 0x91, 0x29, 0xcf, 0xff, 0x00, 0xf2, 0x9b, 0xbb, 0x3b, 0x52, 0xf9, 0x5e, - 0xf9, 0xdf, 0x62, 0xab, 0xd1, 0x60, 0x00, 0x8e, 0xbb, 0x75, 0x93, 0x1c, 0x18, 0x8c, 0x53, 0xbf, - 0x03, 0x13, 0x6d, 0x4c, 0xe9, 0x95, 0xb7, 0x61, 0x98, 0x32, 0x35, 0x3a, 0x8f, 0x8d, 0x64, 0x76, - 0x92, 0xd0, 0xd9, 0x10, 0x3c, 0xfa, 0x2f, 0x34, 0x28, 0xb2, 0x53, 0xaa, 0x15, 0xad, 0x8e, 0x27, - 0x9a, 0xb0, 0x76, 0x0f, 0xe8, 0x06, 0x94, 0x94, 0x0e, 0xd2, 0xa6, 0xe7, 0xa1, 0x10, 0x1e, 0xb8, - 0x56, 0x32, 0xab, 0x07, 0xd6, 0x25, 0x73, 0xfa, 0xe7, 0xa1, 0x60, 0x61, 0x6a, 0x6d, 0x3b, 0xee, - 0x96, 0xd9, 0xf2, 0xe5, 0xd6, 0x02, 0xd5, 0x75, 0xcf, 0xd7, 0x1f, 0x68, 0x70, 0x5a, 0x80, 0xae, - 0xd2, 0x80, 0xe0, 0xe6, 0x53, 0x34, 0x2f, 0x80, 0x33, 0x49, 0x4d, 0xa4, 0x91, 0xdf, 0x83, 0x73, - 0x0d, 0x4c, 0x49, 0x48, 0xcd, 0x1d, 0xd7, 0xdb, 0x73, 0xcd, 0x8d, 0x86, 0x67, 0xed, 0x24, 0x4d, - 0x9e, 0x14, 0x04, 0x37, 0xd9, 0x78, 0x9d, 0x0d, 0xb7, 0xcd, 0x8f, 0xfb, 0x27, 0x97, 0xf6, 0x8f, - 0xfe, 0x79, 0x1e, 0xc6, 0x6f, 0x7b, 0xb4, 0xbd, 0xe9, 0x5f, 0x84, 0xa2, 0xe3, 0x5a, 0x8d, 0x96, - 0x4d, 0xcc, 0xd0, 0x67, 0x19, 0x8c, 0x70, 0xd9, 0xb8, 0xec, 0x5c, 0x65, 0x7d, 0x68, 0x1e, 0xc6, - 0xd4, 0x2e, 0xce, 0x48, 0x21, 0xb2, 0xb6, 0xef, 0xa8, 0xdc, 0xbe, 0x9d, 0x91, 0x74, 0xe8, 0xa8, - 0x91, 0xf4, 0x16, 0x94, 0x45, 0x8a, 0x63, 0x52, 0x8f, 0xeb, 0x6e, 0x57, 0x46, 0x06, 0x49, 0x90, - 0x8a, 0x82, 0xfb, 0xae, 0xc7, 0x6c, 0xb4, 0x9f, 0xc6, 0x02, 0x78, 0x90, 0x83, 0xb3, 0x7c, 0x32, - 0x16, 0xbd, 0x60, 0xcd, 0xa3, 0x8e, 0xbb, 0xa5, 0x66, 0xe5, 0x32, 0x9c, 0xda, 0xf5, 0x28, 0xde, - 0x68, 0x10, 0x13, 0xd3, 0xe4, 0xd4, 0x97, 0xe5, 0xc0, 0x3c, 0x95, 0x73, 0xde, 0xe1, 0xd9, 0xfc, - 0x51, 0x3d, 0xfb, 0x14, 0x5c, 0xf1, 0xc7, 0x1c, 0x94, 0xee, 0x3b, 0xd4, 0x8d, 0x9d, 0xbd, 0x1f, - 0xc2, 0x84, 0xeb, 0x51, 0x12, 0xcb, 0xae, 0xd9, 0xdd, 0x23, 0x7f, 0x88, 0xf4, 0xba, 0xcc, 0x70, - 0xda, 0xed, 0xb0, 0x6b, 0x49, 0x2a, 0x7f, 0x8c, 0x25, 0xa9, 0xa7, 0xe0, 0x40, 0x02, 0xe5, 0xc8, - 0x7f, 0x32, 0x8e, 0x18, 0x30, 0xbe, 0x27, 0xba, 0x44, 0xb2, 0x3d, 0x40, 0x8d, 0x48, 0x42, 0xf1, - 0xac, 0xbb, 0xb0, 0xd7, 0x6e, 0xe8, 0xff, 0xd0, 0x60, 0x52, 0x0e, 0xfe, 0x7f, 0xd6, 0xf9, 0x1a, - 0x30, 0xd5, 0x61, 0xdf, 0x93, 0xab, 0xf2, 0xfd, 0x21, 0x0f, 0x45, 0x1e, 0x2a, 0xa3, 0x55, 0x5f, - 0x85, 0x31, 0x91, 0x27, 0x11, 0x51, 0x40, 0x1b, 0x33, 0xa2, 0x36, 0xfa, 0x29, 0x4c, 0xc7, 0x62, - 0xb5, 0xe5, 0x6c, 0x3a, 0x96, 0x69, 0x13, 0xd7, 0x6b, 0x3a, 0xae, 0x2c, 0x44, 0x88, 0xfd, 0xd1, - 0x2b, 0x6f, 0x59, 0x60, 0x3c, 0xc6, 0xb3, 0xed, 0x10, 0xcf, 0xa1, 0x16, 0xe2, 0x48, 0x68, 0x0e, - 0xce, 0x29, 0x59, 0xed, 0xb2, 0x84, 0xc9, 0x93, 0x83, 0x90, 0xef, 0x95, 0x31, 0x63, 0x4a, 0x12, - 0x2c, 0x44, 0xe3, 0x3c, 0x85, 0x08, 0xd1, 0x5b, 0x50, 0x51, 0xbc, 0x2d, 0x77, 0xc3, 0x73, 0x6d, - 0x76, 0x1a, 0x4b, 0xd6, 0x21, 0xce, 0x3a, 0x29, 0xc7, 0xef, 0xa9, 0x61, 0xc9, 0x79, 0x01, 0xca, - 0x8a, 0xb3, 0xe1, 0x9b, 0xee, 0x26, 0x0d, 0x2b, 0xc3, 0x9c, 0x41, 0x1d, 0x52, 0x1f, 0xf8, 0xb7, - 0x37, 0x69, 0x88, 0x66, 0xe1, 0xac, 0xa2, 0xf3, 0x03, 0xcf, 0xf7, 0x42, 0xdc, 0x10, 0xd4, 0x23, - 0x9c, 0xfa, 0xb4, 0x1c, 0x5c, 0x91, 0x63, 0x9c, 0x67, 0x1e, 0x9e, 0x53, 0x3c, 0xbb, 0x3c, 0xd8, - 0x9a, 0x01, 0xb1, 0x88, 0xe3, 0x53, 0xa5, 0xda, 0x28, 0xe7, 0xad, 0x4a, 0x22, 0x15, 0x90, 0x39, - 0x89, 0x50, 0x4f, 0x27, 0x50, 0x52, 0xb3, 0x25, 0xd7, 0xc4, 0x2a, 0x94, 0xf8, 0x0c, 0x98, 0x4d, - 0x42, 0x71, 0x6c, 0x41, 0xbe, 0xda, 0xcf, 0x14, 0xdc, 0x92, 0x3c, 0x46, 0xd1, 0x8e, 0x37, 0xf5, - 0x0a, 0x4c, 0x5e, 0xdf, 0xc6, 0x8e, 0xbb, 0x82, 0x03, 0xdc, 0x24, 0x94, 0x04, 0x6a, 0x75, 0xe8, - 0xdb, 0x30, 0xd5, 0x31, 0x22, 0x35, 0xb9, 0x05, 0xe0, 0x47, 0xbd, 0x59, 0xa9, 0x24, 0x7f, 0x8b, - 0x88, 0x94, 0x48, 0x43, 0xc5, 0x00, 0xf4, 0x49, 0x38, 0xb3, 0x78, 0x6b, 0xa1, 0x53, 0x03, 0x1b, - 0xce, 0xa6, 0xfa, 0xa5, 0xfc, 0x9b, 0x5d, 0xe4, 0xbf, 0xf2, 0x78, 0xf9, 0x8b, 0x4d, 0x3b, 0x43, - 0xfa, 0x17, 0x39, 0x98, 0x62, 0x27, 0x63, 0xfd, 0x20, 0x16, 0xc6, 0xe5, 0x0e, 0xb9, 0x0f, 0xe5, - 0xd4, 0xb9, 0x20, 0x7d, 0x3e, 0x70, 0xd5, 0x25, 0x79, 0x2c, 0x74, 0xab, 0x7f, 0xe7, 0xbb, 0xd5, - 0xbf, 0x9f, 0x46, 0x78, 0x77, 0xa1, 0xd2, 0xe9, 0x8f, 0x28, 0xce, 0x97, 0x78, 0xfa, 0xc3, 0xd3, - 0x05, 0x66, 0x53, 0xa7, 0xf7, 0x93, 0x19, 0xff, 0xaa, 0xa2, 0x66, 0x90, 0x06, 0xb1, 0xbc, 0xc0, - 0x36, 0x8a, 0x61, 0xbc, 0x93, 0x4f, 0xc0, 0xea, 0x1e, 0xf6, 0x33, 0x26, 0x20, 0x5d, 0xf6, 0xca, - 0x1d, 0x47, 0xd9, 0xeb, 0x5b, 0x3d, 0x01, 0x06, 0x54, 0x3a, 0xfd, 0x11, 0x3d, 0x77, 0x0c, 0x31, - 0x4b, 0xa4, 0xdb, 0xf5, 0x4c, 0xb7, 0xef, 0x61, 0x5f, 0x7a, 0x9b, 0xd3, 0xeb, 0xff, 0xd1, 0x60, - 0xf2, 0x76, 0xab, 0xd1, 0x70, 0x36, 0x1d, 0x12, 0x24, 0x6f, 0x5b, 0x8b, 0x70, 0xd2, 0x55, 0x23, - 0xd2, 0xbb, 0x97, 0x7a, 0x98, 0x16, 0x21, 0x19, 0x6d, 0xd6, 0x6f, 0xb5, 0x4b, 0x67, 0x60, 0xaa, - 0xc3, 0x7a, 0xe9, 0xd1, 0x33, 0x30, 0x2c, 0x6e, 0x23, 0xe2, 0x08, 0x14, 0x0d, 0x7d, 0x0d, 0x9e, - 0x8d, 0x9d, 0xa4, 0xcb, 0xee, 0xa6, 0x57, 0x3f, 0x58, 0xc2, 0x61, 0x74, 0x8d, 0x16, 0xcf, 0x4e, - 0xb9, 0x41, 0x9f, 0x9d, 0xf4, 0xcf, 0x34, 0x98, 0x4c, 0x01, 0x2b, 0xc8, 0x0b, 0x30, 0x1e, 0x52, - 0x1c, 0x24, 0x73, 0xf0, 0xa5, 0x13, 0x46, 0x81, 0xf7, 0x8a, 0x0c, 0xfc, 0x81, 0xa6, 0x21, 0x1d, - 0x80, 0xb8, 0x76, 0xe2, 0xde, 0xb5, 0xa4, 0x19, 0x27, 0x89, 0x6b, 0x47, 0x34, 0xf5, 0x32, 0x14, - 0xcd, 0x38, 0x58, 0xbd, 0x08, 0x05, 0xb3, 0xcd, 0xa5, 0xff, 0x3b, 0x07, 0xe5, 0x94, 0x1a, 0xe8, - 0x19, 0x18, 0x49, 0x49, 0x96, 0x6d, 0x26, 0xf4, 0x90, 0xf6, 0xa6, 0x13, 0x99, 0xfc, 0x31, 0xbc, - 0x1d, 0xae, 0x43, 0xc1, 0x27, 0x01, 0xcb, 0x4a, 0xa8, 0xb3, 0x4b, 0xe4, 0xe5, 0x6e, 0x6e, 0xd0, - 0xbc, 0xaf, 0x8d, 0x60, 0xc4, 0xe1, 0xd0, 0x0d, 0x18, 0x62, 0x5b, 0x89, 0xe7, 0x02, 0x83, 0xa7, - 0x93, 0x6b, 0x0e, 0xd9, 0x33, 0x38, 0x40, 0xfd, 0x24, 0x8c, 0x2a, 0x6f, 0xff, 0x18, 0xa6, 0x3a, - 0xe6, 0xbc, 0x5d, 0x5e, 0xa3, 0xfb, 0xa6, 0xe3, 0x6e, 0x7a, 0x72, 0x4b, 0x5f, 0xec, 0xe3, 0x65, - 0x87, 0x23, 0x8c, 0xd0, 0x7d, 0xf6, 0x57, 0xc7, 0xf0, 0x5c, 0xc6, 0x4a, 0x3d, 0x36, 0x11, 0x1f, - 0x43, 0x51, 0x5e, 0xe4, 0x25, 0xe4, 0x07, 0x50, 0xe0, 0xe7, 0x62, 0xc0, 0x43, 0xcc, 0x61, 0xce, - 0x00, 0x70, 0xa3, 0xdf, 0xfa, 0x57, 0x2c, 0x36, 0xa5, 0xee, 0xa6, 0x4f, 0x42, 0x10, 0xba, 0x05, - 0xe3, 0x8e, 0x4d, 0x5c, 0xea, 0xd0, 0x03, 0x73, 0x87, 0x1c, 0xc8, 0xe5, 0x7c, 0xb9, 0x47, 0xd0, - 0x59, 0x96, 0x2c, 0x37, 0xc9, 0x81, 0x51, 0x70, 0xda, 0x0d, 0xfd, 0xbf, 0x79, 0x38, 0xdd, 0x45, - 0x64, 0xb7, 0xac, 0x41, 0x3b, 0x96, 0xac, 0xe1, 0xbb, 0x30, 0xc4, 0xcf, 0x5c, 0xa1, 0xf7, 0x8b, - 0xbd, 0x82, 0x34, 0xd3, 0x88, 0x33, 0x3c, 0x81, 0x7b, 0x7b, 0xe2, 0xd0, 0x18, 0x3a, 0xfc, 0xa1, - 0x71, 0x1e, 0x4a, 0x62, 0x93, 0x98, 0x56, 0x40, 0x30, 0x25, 0x36, 0xdf, 0x78, 0x43, 0x46, 0x51, - 0xf4, 0x5e, 0x17, 0x9d, 0x2c, 0x36, 0x4a, 0x32, 0x11, 0xab, 0x47, 0x54, 0x6c, 0x14, 0xbd, 0xbc, - 0x74, 0xc4, 0xc2, 0x54, 0x15, 0xc6, 0x7c, 0x2f, 0x74, 0x78, 0xac, 0x19, 0xe5, 0x40, 0x51, 0x1b, - 0xbd, 0x07, 0x23, 0xa1, 0xd7, 0x0a, 0x2c, 0x52, 0x19, 0xeb, 0xae, 0x6f, 0x32, 0x63, 0x64, 0xee, - 0x5b, 0xe5, 0xf4, 0x86, 0xe4, 0xe3, 0x51, 0x35, 0xae, 0x86, 0xfe, 0xf7, 0x3c, 0x40, 0xfb, 0xa8, - 0x7d, 0x62, 0x8f, 0x74, 0xe8, 0x5d, 0x79, 0xea, 0x8b, 0x89, 0x7f, 0x39, 0x85, 0x66, 0x93, 0xfd, - 0xe4, 0xc9, 0x1f, 0xfb, 0x00, 0x80, 0xb1, 0x25, 0xbc, 0x92, 0x4f, 0x79, 0xe5, 0xb8, 0x26, 0x72, - 0x05, 0x0a, 0xe2, 0xf5, 0x5e, 0xdc, 0x95, 0x87, 0xbb, 0x06, 0xfa, 0x84, 0xa6, 0x75, 0x4c, 0xad, - 0x6d, 0xa6, 0xae, 0x78, 0x33, 0xe6, 0xb7, 0x64, 0xf0, 0xa2, 0xdf, 0xe8, 0x72, 0x7b, 0x69, 0x34, - 0xb0, 0xd3, 0x24, 0x76, 0x34, 0xeb, 0x6a, 0x71, 0x88, 0x6e, 0x36, 0xef, 0xed, 0xb9, 0x1d, 0x3d, - 0xe4, 0xdc, 0x9e, 0x82, 0xb2, 0x99, 0x14, 0xa7, 0xff, 0x53, 0x83, 0xa9, 0x3b, 0x7b, 0x2e, 0xb1, - 0x57, 0xa4, 0xb3, 0x96, 0xed, 0x28, 0x69, 0xba, 0x07, 0x25, 0xe5, 0x42, 0x76, 0xd0, 0x46, 0x89, - 0xf0, 0x63, 0xe7, 0x46, 0xe1, 0xf0, 0xe9, 0x66, 0x76, 0xf8, 0xf1, 0x0e, 0x66, 0xc7, 0x1d, 0x18, - 0xa7, 0x01, 0xe6, 0x97, 0x58, 0x1f, 0x3b, 0x2a, 0x1d, 0xbb, 0xf8, 0x38, 0xd0, 0xbb, 0x82, 0x7e, - 0x05, 0x3b, 0xc1, 0x92, 0xc6, 0x4f, 0x4a, 0xd5, 0x64, 0x89, 0x00, 0x33, 0x2b, 0xa9, 0x28, 0x5f, - 0xc5, 0x71, 0x21, 0xba, 0x05, 0x95, 0x4e, 0x33, 0xa3, 0xa7, 0xcc, 0x42, 0xc4, 0x9e, 0xf9, 0x9d, - 0x4d, 0x57, 0x23, 0x97, 0x6d, 0x03, 0xfc, 0xe8, 0xf7, 0xec, 0x9f, 0x4e, 0xc3, 0x69, 0x76, 0x3a, - 0xae, 0x04, 0x1e, 0xf5, 0x2c, 0xaf, 0xb1, 0x4a, 0x82, 0x5d, 0xc7, 0x22, 0xe8, 0x3e, 0x8c, 0x88, - 0x84, 0x0c, 0x65, 0xbe, 0x1a, 0x24, 0xd2, 0xd5, 0xea, 0x85, 0x5e, 0x64, 0x52, 0xf3, 0x1d, 0x18, - 0x8f, 0x97, 0xbc, 0xd1, 0x2b, 0x8f, 0xe7, 0x4b, 0x94, 0xe8, 0xab, 0xaf, 0xf6, 0x47, 0x2c, 0x44, - 0x5d, 0xd1, 0xd0, 0x1a, 0x0c, 0xf3, 0x13, 0x0c, 0xbd, 0x94, 0xc5, 0x18, 0xaf, 0x84, 0x57, 0xcf, - 0xf7, 0xa0, 0x8a, 0x70, 0x3f, 0x81, 0x52, 0xf2, 0x64, 0x44, 0xaf, 0x3d, 0x96, 0x35, 0x5d, 0xdd, - 0xad, 0xd6, 0xfa, 0x25, 0x8f, 0x44, 0x7e, 0x04, 0xa3, 0xb2, 0x2a, 0x85, 0x32, 0x5d, 0x9d, 0x2c, - 0x9f, 0x56, 0x2f, 0xf6, 0xa4, 0x93, 0x73, 0x12, 0x44, 0x95, 0x43, 0x55, 0xf1, 0x42, 0xb5, 0x1e, - 0xbc, 0xa9, 0xd2, 0x5f, 0x75, 0xa6, 0x6f, 0x7a, 0x29, 0xf3, 0x43, 0x18, 0x11, 0x85, 0x94, 0xec, - 0x05, 0x96, 0x28, 0x8b, 0x65, 0x2f, 0xb0, 0x64, 0x3d, 0xe6, 0x8a, 0xc6, 0xcc, 0x49, 0xd5, 0x35, - 0xb2, 0xcd, 0xe9, 0x5e, 0x65, 0xc9, 0x36, 0x27, 0xab, 0xf6, 0xd2, 0x80, 0x62, 0xa2, 0x28, 0x82, - 0x32, 0x97, 0x6a, 0xb7, 0x9a, 0x4a, 0xf5, 0xb5, 0x3e, 0xa9, 0xa5, 0x34, 0x0f, 0x4a, 0xc9, 0xb7, - 0xfe, 0xec, 0xf5, 0xd7, 0xf5, 0x3b, 0x85, 0xec, 0xf5, 0x97, 0xf1, 0x09, 0x81, 0x07, 0xa5, 0xe4, - 0x23, 0x7d, 0xb6, 0xc0, 0xae, 0x1f, 0x0a, 0x64, 0x0b, 0xcc, 0x78, 0xfb, 0x6f, 0xc1, 0x44, 0xfa, - 0xed, 0x1b, 0x65, 0x4e, 0x4a, 0xc6, 0xdb, 0x7d, 0xf5, 0x4a, 0xff, 0x0c, 0x52, 0xac, 0x09, 0x63, - 0xea, 0x6d, 0x19, 0x65, 0x6e, 0x9f, 0xd4, 0xab, 0x79, 0xf5, 0x52, 0x6f, 0xc2, 0x68, 0x6d, 0xb6, - 0x60, 0x22, 0x5d, 0xc5, 0xc9, 0xb6, 0x2b, 0xa3, 0xfe, 0x95, 0x6d, 0x57, 0x66, 0x81, 0xa8, 0x05, - 0x13, 0xe9, 0xda, 0x45, 0xb6, 0xd8, 0x8c, 0xaa, 0x4f, 0xb6, 0xd8, 0xcc, 0xb2, 0x48, 0x00, 0xe5, - 0xd4, 0xfd, 0x3e, 0x7b, 0x27, 0x76, 0x2f, 0x83, 0x64, 0xef, 0xc4, 0xac, 0xc2, 0xc1, 0x67, 0x1a, - 0x9c, 0xed, 0x7a, 0xf3, 0x42, 0xd7, 0xfa, 0xbc, 0x60, 0x25, 0x4a, 0x0a, 0xd5, 0x37, 0x06, 0xe4, - 0x92, 0x6a, 0xd0, 0xce, 0x9b, 0x7c, 0xad, 0xdf, 0x0b, 0x5e, 0x2f, 0xd3, 0x33, 0x6e, 0xad, 0x57, - 0x34, 0xf4, 0x73, 0x40, 0x9d, 0x1f, 0x40, 0xa1, 0xab, 0x03, 0x7f, 0x96, 0x58, 0x9d, 0x1d, 0x84, - 0x45, 0x9a, 0xfc, 0xa9, 0x06, 0x67, 0xba, 0x7d, 0x14, 0x8c, 0x5e, 0xcf, 0xdc, 0x20, 0xd9, 0x9f, - 0x37, 0x57, 0xaf, 0x0d, 0xc6, 0x24, 0x75, 0xd8, 0x83, 0x89, 0x74, 0xd2, 0x94, 0xbd, 0xd0, 0x33, - 0xb2, 0xc8, 0xec, 0x85, 0x9e, 0x95, 0x8f, 0x5d, 0xd1, 0xd0, 0x3e, 0x9c, 0xea, 0xf8, 0x3a, 0x1c, - 0x65, 0x02, 0x65, 0x7d, 0x2a, 0x5f, 0xbd, 0x3a, 0x00, 0x87, 0x90, 0x3d, 0xeb, 0xb7, 0xbf, 0x26, - 0x51, 0xd9, 0xdb, 0xc7, 0x30, 0xa6, 0xba, 0xb2, 0xc3, 0x58, 0xea, 0x13, 0x94, 0xec, 0x30, 0x96, - 0xfe, 0xae, 0xa4, 0xfe, 0x79, 0xee, 0x2f, 0x0f, 0xa7, 0xb5, 0xaf, 0x1f, 0x4e, 0x6b, 0xdf, 0x3c, - 0x9c, 0xd6, 0xbe, 0x7c, 0x34, 0x7d, 0xe2, 0xeb, 0x47, 0xd3, 0x27, 0xfe, 0xf6, 0x68, 0xfa, 0x04, - 0x54, 0x2d, 0xaf, 0x99, 0x81, 0x53, 0x3f, 0x19, 0x25, 0x9a, 0x2b, 0xda, 0x47, 0x77, 0xb6, 0x1c, - 0xba, 0xdd, 0xda, 0xa8, 0x59, 0x5e, 0x73, 0xc6, 0xf2, 0xc2, 0xa6, 0x17, 0xce, 0x04, 0xa4, 0x81, - 0x0f, 0x48, 0x30, 0xb3, 0x3b, 0x1b, 0xfd, 0xe4, 0x17, 0x84, 0x70, 0xa6, 0xfb, 0x7f, 0x66, 0xbc, - 0xcd, 0x5a, 0xaa, 0xf1, 0xbb, 0x5c, 0x7e, 0x65, 0xed, 0x47, 0xbf, 0xcf, 0x4d, 0xae, 0x28, 0xe1, - 0x4c, 0x5a, 0x6d, 0x4d, 0x0e, 0xff, 0xb5, 0x3d, 0xb0, 0xce, 0x06, 0xd6, 0xd5, 0xc0, 0xc3, 0x9c, - 0xde, 0x7d, 0x60, 0xfd, 0xc6, 0x4a, 0x5d, 0xbd, 0xc7, 0xfc, 0x2b, 0x57, 0x51, 0x44, 0x73, 0x73, - 0x8c, 0x6a, 0x6e, 0x4e, 0x91, 0x6d, 0x8c, 0xf0, 0x7f, 0x80, 0x78, 0xfd, 0x7f, 0x01, 0x00, 0x00, - 0xff, 0xff, 0x8e, 0xb9, 0xe6, 0x1e, 0x3f, 0x32, 0x00, 0x00, + // 3262 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x3b, 0x5b, 0x53, 0x1c, 0xc7, + 0xd5, 0x9e, 0x05, 0x71, 0x39, 0xb0, 0x2c, 0x8c, 0x04, 0xac, 0xf6, 0xb3, 0xb1, 0x3d, 0xb6, 0x6c, + 0x7c, 0x5b, 0x10, 0x96, 0x5d, 0x36, 0xbe, 0x7c, 0x66, 0x25, 0x4b, 0xc2, 0xb6, 0x24, 0xbe, 0x41, + 0x42, 0xfe, 0xf8, 0xe4, 0x6f, 0xd2, 0xcc, 0x34, 0xec, 0x94, 0x66, 0x67, 0x46, 0x33, 0xbd, 0x2c, + 0x24, 0x4f, 0xa9, 0xa4, 0xca, 0x55, 0x49, 0x1e, 0x9c, 0xb8, 0xe2, 0xaa, 0xe4, 0x31, 0x8f, 0xf1, + 0x5b, 0xf2, 0x27, 0x12, 0xe7, 0xc5, 0x8f, 0x79, 0x4a, 0x39, 0xf2, 0x5b, 0x52, 0x95, 0xdf, 0x90, + 0xea, 0xdb, 0xdc, 0x76, 0x5b, 0xec, 0x02, 0x7a, 0xc9, 0x13, 0xd3, 0xa7, 0xcf, 0xbd, 0xbb, 0x4f, + 0x9f, 0x3e, 0x67, 0x81, 0x67, 0x43, 0xec, 0xb7, 0x5b, 0x3b, 0x11, 0x5a, 0xda, 0x77, 0x71, 0x67, + 0x69, 0xff, 0x22, 0xf2, 0xc2, 0x26, 0xba, 0xc8, 0x46, 0xf5, 0x30, 0x0a, 0x48, 0xa0, 0xcf, 0x49, + 0x94, 0x3a, 0x03, 0x4a, 0x94, 0xda, 0xf3, 0x09, 0xa9, 0x1d, 0x44, 0x78, 0x09, 0x85, 0x61, 0x4a, + 0x8e, 0xc2, 0x90, 0x53, 0xd7, 0x16, 0x0b, 0x58, 0x71, 0x8c, 0x49, 0x06, 0x8f, 0x0e, 0x05, 0xe6, + 0x4a, 0x1e, 0xd3, 0x0e, 0x5a, 0x61, 0xe0, 0x63, 0x9f, 0x2c, 0xd9, 0x4d, 0xe4, 0xfa, 0x29, 0x0d, + 0x1b, 0x0a, 0x9a, 0xba, 0x8a, 0xc6, 0xc1, 0x07, 0x29, 0x85, 0x83, 0x0f, 0x8e, 0xc2, 0xdf, 0xc5, + 0x38, 0xc5, 0xdf, 0xc5, 0xf8, 0x28, 0x7c, 0x77, 0xc7, 0x4e, 0xf1, 0xdd, 0x1d, 0xfb, 0x28, 0xfc, + 0xd8, 0xce, 0x58, 0x1d, 0xdb, 0xd2, 0xe6, 0x86, 0x12, 0xbf, 0xe9, 0x62, 0xcf, 0xc1, 0x8e, 0x15, + 0x06, 0x81, 0x97, 0xa1, 0xcc, 0x82, 0x8f, 0xf2, 0x5b, 0x4c, 0xd0, 0xfd, 0x8c, 0x55, 0x6c, 0x28, + 0x68, 0x5e, 0xc8, 0xd3, 0xdc, 0xc7, 0x87, 0x71, 0x8a, 0x48, 0x47, 0x02, 0xaf, 0xb0, 0xc6, 0x7e, + 0xbb, 0x95, 0xa2, 0xf9, 0xed, 0x96, 0xc0, 0xba, 0x94, 0xc7, 0x22, 0x11, 0xf2, 0x63, 0x64, 0x13, + 0x37, 0xc8, 0xac, 0x5a, 0x06, 0x28, 0xa8, 0x5e, 0x2e, 0x50, 0x1d, 0x34, 0x51, 0xdc, 0xcc, 0x10, + 0xb0, 0x71, 0xb7, 0xbe, 0xd1, 0x61, 0x48, 0x82, 0x25, 0x92, 0xf5, 0x27, 0x91, 0xfe, 0x34, 0xbe, + 0xd3, 0xa0, 0xba, 0xd6, 0x26, 0xcd, 0x20, 0x72, 0x7f, 0x88, 0xd7, 0x7c, 0xa7, 0xd1, 0x76, 0x3d, + 0xc7, 0xc4, 0x0f, 0xda, 0x38, 0x26, 0xfa, 0xff, 0xc3, 0x74, 0x46, 0x0b, 0x2b, 0xf4, 0x90, 0x5f, + 0xd5, 0x9e, 0xd1, 0x16, 0x27, 0x56, 0x5e, 0x4f, 0xd6, 0xad, 0x4e, 0x75, 0xa9, 0x67, 0x95, 0x95, + 0x52, 0xea, 0xb7, 0x53, 0xe0, 0x86, 0x87, 0x7c, 0xb3, 0x42, 0xf2, 0x00, 0xdd, 0x01, 0x1d, 0x09, + 0xd9, 0x88, 0x49, 0x70, 0x10, 0x41, 0xd5, 0x12, 0x93, 0xf0, 0x46, 0x3f, 0x12, 0xd6, 0xb2, 0xd4, + 0x57, 0x10, 0x41, 0xe6, 0x0c, 0x2a, 0x82, 0x0c, 0x1f, 0xce, 0xf7, 0xb0, 0x30, 0x0e, 0x03, 0x3f, + 0xc6, 0xfa, 0xff, 0xc0, 0x44, 0x86, 0xb3, 0xb0, 0x6e, 0x69, 0x40, 0xeb, 0xcc, 0x2c, 0x0f, 0xe3, + 0x37, 0x1a, 0xfc, 0x57, 0x23, 0x0a, 0x90, 0x63, 0xa3, 0x98, 0x64, 0xb1, 0x84, 0x57, 0x4f, 0x5f, + 0xa4, 0xfe, 0x22, 0x54, 0x50, 0x07, 0xb9, 0xc4, 0x72, 0x30, 0xc1, 0x9c, 0x2d, 0xf5, 0xe2, 0x98, + 0x39, 0xc5, 0xc0, 0x57, 0x24, 0xd4, 0xf8, 0x5c, 0x83, 0x27, 0x7b, 0xeb, 0x26, 0xfc, 0xf1, 0x2e, + 0x94, 0x5c, 0x47, 0xe8, 0xf4, 0x6a, 0x51, 0x27, 0xbe, 0xc1, 0x7a, 0xa9, 0xb3, 0xee, 0x98, 0x25, + 0xd7, 0xd1, 0x5f, 0x82, 0xe9, 0x44, 0x03, 0xab, 0x89, 0xdd, 0xbd, 0x26, 0x61, 0x8a, 0x0c, 0x9b, + 0x95, 0x04, 0x7e, 0x9d, 0x81, 0x8d, 0x3f, 0x9f, 0x85, 0xf3, 0x85, 0x0d, 0xe2, 0xe3, 0x48, 0xfa, + 0xe8, 0x39, 0x28, 0xe3, 0x83, 0xd0, 0x8d, 0x0e, 0x25, 0x17, 0x8d, 0x71, 0x99, 0xe4, 0x40, 0xce, + 0x42, 0x7f, 0x07, 0x86, 0x76, 0x31, 0x16, 0xfb, 0xe5, 0xa5, 0x82, 0xb2, 0xc9, 0xa9, 0xae, 0xd3, + 0xe0, 0x94, 0xe8, 0x7c, 0x15, 0x63, 0x93, 0x52, 0xe9, 0x1f, 0xc2, 0x70, 0x0b, 0xb7, 0x82, 0xea, + 0x10, 0xa3, 0xbe, 0xd8, 0x8f, 0xfb, 0x6f, 0xe0, 0x56, 0xb0, 0xe1, 0x21, 0xd7, 0x27, 0xf8, 0x80, + 0x98, 0x8c, 0x5c, 0x5f, 0x83, 0x91, 0x38, 0x68, 0x47, 0x36, 0xae, 0x0e, 0xf7, 0x54, 0x83, 0x85, + 0x86, 0x74, 0xbf, 0x3a, 0x4e, 0x84, 0xe3, 0x78, 0xdd, 0x77, 0xf0, 0x81, 0x29, 0x08, 0x75, 0x13, + 0x46, 0x83, 0x36, 0x09, 0xdb, 0x24, 0xae, 0x9e, 0x7b, 0x66, 0x68, 0x71, 0x62, 0xe5, 0xad, 0x7a, + 0xef, 0x0b, 0xa4, 0xae, 0xf4, 0x57, 0xfd, 0x16, 0x63, 0x60, 0x4a, 0x46, 0xfa, 0x27, 0x70, 0x26, + 0xee, 0xa0, 0x30, 0xae, 0x2e, 0x30, 0x8e, 0x6f, 0x0e, 0xce, 0x71, 0xb3, 0x83, 0x42, 0x93, 0x33, + 0xd1, 0xef, 0xc1, 0x04, 0xfd, 0xb0, 0x6c, 0x0f, 0xb9, 0xad, 0xb8, 0xfa, 0x34, 0xe3, 0xf9, 0xce, + 0xf1, 0x78, 0x5e, 0xa6, 0x3c, 0x4c, 0x88, 0xe5, 0x27, 0xe3, 0xee, 0x60, 0x0f, 0xef, 0xb1, 0x13, + 0x1b, 0x57, 0x17, 0x19, 0xf7, 0xd5, 0xc1, 0xb9, 0x5f, 0xe1, 0x4c, 0xb0, 0x99, 0x65, 0xa7, 0xef, + 0x40, 0xb9, 0xed, 0x67, 0xf9, 0xaf, 0x30, 0xfe, 0xef, 0x0e, 0xce, 0xff, 0x8e, 0x64, 0x83, 0xcd, + 0x3c, 0x4b, 0x7d, 0x1b, 0x66, 0xdc, 0x1d, 0xdb, 0x8a, 0xb0, 0x87, 0x0e, 0x2d, 0x4e, 0x1b, 0x57, + 0xdf, 0x65, 0x72, 0xea, 0xca, 0x6d, 0x49, 0xef, 0xc0, 0x44, 0xea, 0xfa, 0x8e, 0x6d, 0x52, 0x6a, + 0xb3, 0xe2, 0x8a, 0xaf, 0x35, 0x5b, 0xea, 0x3f, 0xe3, 0xda, 0xf1, 0xca, 0xb2, 0xd5, 0x71, 0x49, + 0xd3, 0x89, 0x50, 0x07, 0x79, 0x71, 0xf5, 0x3d, 0xc6, 0xfb, 0x8d, 0x3e, 0x79, 0x53, 0xf2, 0xbb, + 0x09, 0xb5, 0x39, 0xed, 0xe6, 0x01, 0xb1, 0x8e, 0x61, 0x2a, 0x0c, 0x62, 0x97, 0x9d, 0xda, 0x20, + 0xc4, 0x7e, 0x5c, 0xbd, 0xca, 0x04, 0xbc, 0x3f, 0xb8, 0x93, 0x36, 0x04, 0x9f, 0x5b, 0x21, 0xf6, + 0xcd, 0x72, 0x98, 0x19, 0xc5, 0x7a, 0x13, 0x2a, 0x89, 0x18, 0xdb, 0x0b, 0x62, 0x1c, 0x57, 0xaf, + 0x31, 0x39, 0xff, 0x7d, 0x7c, 0x39, 0x97, 0x29, 0x1f, 0x33, 0x51, 0x9f, 0x0d, 0x63, 0xfd, 0x01, + 0xe8, 0x89, 0x24, 0xe9, 0xb7, 0xb8, 0x7a, 0x9d, 0x09, 0x6b, 0x1c, 0x5f, 0x98, 0xf4, 0x99, 0x39, + 0x13, 0x16, 0x20, 0x71, 0xed, 0x27, 0x1a, 0x8c, 0xf0, 0x53, 0xa8, 0xbf, 0x0d, 0x67, 0xf6, 0x91, + 0xd7, 0xc6, 0x22, 0x8c, 0x3e, 0x57, 0x58, 0x26, 0x9e, 0xc2, 0x25, 0x62, 0xb7, 0x28, 0xaa, 0xc9, + 0x29, 0xf4, 0xf7, 0x61, 0x14, 0xf1, 0x18, 0x21, 0xc2, 0xda, 0xf3, 0xfd, 0xc4, 0x13, 0x53, 0x12, + 0xd5, 0xbe, 0x2c, 0xc1, 0x30, 0x3d, 0x65, 0x27, 0xd1, 0xe1, 0x3a, 0x4c, 0x12, 0x14, 0xed, 0x61, + 0x62, 0x31, 0x2c, 0xa1, 0xc8, 0x85, 0x47, 0x73, 0x58, 0xa3, 0xc3, 0x75, 0xc7, 0x9c, 0xe0, 0xa4, + 0x6c, 0x28, 0x03, 0xf4, 0xd0, 0xb1, 0x02, 0xf4, 0x3a, 0x94, 0x59, 0xbc, 0xb1, 0xa4, 0x43, 0x86, + 0x07, 0x70, 0xc8, 0x24, 0x23, 0x15, 0xa3, 0x9a, 0x0d, 0xe3, 0x49, 0xe8, 0xd1, 0xb7, 0xa0, 0xc2, + 0x83, 0x59, 0xd0, 0x6a, 0xb9, 0xa4, 0x85, 0x7d, 0x22, 0x7c, 0xf4, 0x5a, 0x86, 0x33, 0xcb, 0x99, + 0xea, 0x34, 0x4d, 0x4a, 0x58, 0x6f, 0x12, 0x44, 0xf0, 0xe5, 0x84, 0xc8, 0x9c, 0x62, 0x21, 0x2c, + 0x19, 0xd7, 0x7e, 0xad, 0xc1, 0x98, 0x0c, 0x41, 0xfa, 0x2a, 0x8c, 0xa0, 0x56, 0xd0, 0x4e, 0x78, + 0x1b, 0x05, 0xad, 0x69, 0x2a, 0x98, 0x2a, 0xcd, 0x30, 0x4d, 0x41, 0xa1, 0xdf, 0x80, 0xf1, 0x08, + 0x11, 0xcc, 0x93, 0x21, 0xee, 0xbb, 0x65, 0xa5, 0xef, 0x78, 0x8e, 0x9a, 0xb0, 0x32, 0x11, 0xc1, + 0x2c, 0x0f, 0x1a, 0x8b, 0xc4, 0x57, 0xed, 0x2b, 0x0d, 0x20, 0x0d, 0x5d, 0x27, 0xd9, 0x18, 0x39, + 0xc5, 0x4a, 0x27, 0x56, 0x6c, 0x1b, 0x26, 0xb3, 0xd1, 0x42, 0xff, 0x08, 0xc6, 0xe4, 0xb1, 0x12, + 0xca, 0xa9, 0x83, 0x27, 0x7d, 0xa0, 0x24, 0xbc, 0x25, 0x17, 0x33, 0xa1, 0xaf, 0xed, 0x40, 0x39, + 0x17, 0x21, 0x68, 0xd2, 0x95, 0x44, 0x84, 0x24, 0xc1, 0x59, 0x1e, 0x8c, 0xff, 0xba, 0x63, 0x42, + 0x98, 0x7c, 0xd7, 0x3e, 0x2f, 0xc1, 0x74, 0x31, 0x32, 0x3c, 0x06, 0x39, 0xd4, 0x2f, 0x11, 0x8e, + 0x71, 0xb4, 0x8f, 0x65, 0x50, 0xe8, 0xd3, 0x2f, 0xa6, 0xa0, 0x32, 0x13, 0x7a, 0xfd, 0x36, 0x4c, + 0x92, 0x08, 0x39, 0xae, 0xbf, 0x67, 0x85, 0xc8, 0x8d, 0x14, 0xd9, 0x8f, 0x82, 0xdf, 0x6d, 0x4e, + 0xb9, 0x81, 0xdc, 0x88, 0xa5, 0x9f, 0x72, 0x60, 0x60, 0xa8, 0xf5, 0x0a, 0x9e, 0x22, 0xa5, 0xbc, + 0x06, 0xc3, 0x27, 0x7d, 0x39, 0x30, 0x06, 0xc6, 0x1e, 0xcc, 0x8a, 0x13, 0xdd, 0x38, 0xe4, 0x29, + 0x94, 0xc8, 0x16, 0x6f, 0x42, 0x59, 0x04, 0x09, 0xcb, 0xa5, 0x70, 0x21, 0x6a, 0x80, 0x5c, 0x6c, + 0x12, 0x65, 0x46, 0xc6, 0xa7, 0x30, 0x57, 0x14, 0x24, 0x6c, 0xc9, 0xc4, 0x67, 0xed, 0x18, 0xf1, + 0xd9, 0x98, 0x81, 0xca, 0x5d, 0xe4, 0x79, 0x2c, 0x54, 0x72, 0xe5, 0x8d, 0x2d, 0x98, 0x4e, 0x41, + 0x42, 0x4c, 0x03, 0xc6, 0x3b, 0x0c, 0x96, 0xee, 0xa1, 0x0b, 0x8f, 0x14, 0x94, 0x70, 0x18, 0xeb, + 0x88, 0x2f, 0xe3, 0x2e, 0xcc, 0x32, 0xdd, 0x1b, 0x87, 0x52, 0x0b, 0xe1, 0xad, 0x93, 0xda, 0xd0, + 0x84, 0xb9, 0x22, 0x63, 0xa1, 0xf6, 0x69, 0xaf, 0xc3, 0xaf, 0x34, 0x98, 0xff, 0x30, 0x6c, 0xe2, + 0x16, 0x8e, 0x90, 0x57, 0xb0, 0xe2, 0x94, 0x65, 0xd1, 0x27, 0x94, 0xe3, 0xc6, 0x21, 0xcd, 0xe0, + 0xec, 0xc0, 0xdf, 0x75, 0xa3, 0x96, 0x7c, 0x42, 0x09, 0xf0, 0x65, 0x0e, 0x35, 0xb6, 0xa1, 0xda, + 0xad, 0xd3, 0x29, 0x6d, 0x8f, 0x3f, 0x68, 0x50, 0x69, 0x20, 0x0f, 0xf9, 0x36, 0x4e, 0x0c, 0xdd, + 0x80, 0x29, 0x64, 0xdb, 0xf4, 0x66, 0xb0, 0x76, 0x5d, 0x8f, 0xe0, 0x68, 0x70, 0x4b, 0xcb, 0x82, + 0xc1, 0x55, 0x46, 0xaf, 0xdf, 0x80, 0x0a, 0x0b, 0xf3, 0x96, 0xeb, 0x48, 0x96, 0x03, 0xdd, 0xf1, + 0x65, 0xc4, 0x3f, 0x38, 0x3b, 0xe3, 0x2b, 0x0d, 0xa6, 0x53, 0xa5, 0x85, 0x27, 0x2e, 0xc3, 0xa8, + 0x10, 0x3a, 0xb8, 0xba, 0x92, 0x52, 0x7f, 0x0f, 0x46, 0x77, 0x38, 0x63, 0xa1, 0x60, 0x5f, 0xb7, + 0x95, 0xa4, 0x31, 0x2a, 0x50, 0xa6, 0x97, 0x76, 0x5b, 0xba, 0xd2, 0xf8, 0xb9, 0x06, 0x53, 0x12, + 0x22, 0xf4, 0x5c, 0x84, 0xe9, 0xdd, 0xb6, 0xe7, 0x59, 0xf1, 0xa1, 0x6f, 0xe7, 0xdf, 0x9a, 0x53, + 0x14, 0xbe, 0x79, 0xe8, 0xdb, 0xe2, 0xb5, 0x59, 0x87, 0xb3, 0x21, 0x8a, 0x88, 0x8b, 0xf2, 0xc8, + 0xfc, 0x79, 0x3b, 0x23, 0xa6, 0x32, 0xf8, 0x4f, 0xc3, 0x84, 0x8d, 0x88, 0xdd, 0xa4, 0xb1, 0xb6, + 0x1d, 0xb2, 0x48, 0x3b, 0x66, 0x82, 0x04, 0xdd, 0x09, 0x8d, 0x59, 0x38, 0xcb, 0x95, 0xd9, 0x24, + 0x11, 0x46, 0x2d, 0xa9, 0xe4, 0xd7, 0x1a, 0x9c, 0xcb, 0xc3, 0x85, 0xaa, 0x6f, 0xc3, 0x79, 0x0f, + 0x11, 0x1c, 0x13, 0xeb, 0xbe, 0x1f, 0x74, 0x7c, 0x6b, 0xc7, 0x0b, 0xec, 0xfb, 0x79, 0x9d, 0xe7, + 0x38, 0xc2, 0xc7, 0x74, 0xbe, 0x41, 0xa7, 0x85, 0x2e, 0xbd, 0xac, 0x2c, 0x0d, 0x62, 0xe5, 0x90, + 0xc2, 0x4a, 0xe3, 0x97, 0x25, 0x98, 0xbc, 0x19, 0x90, 0x74, 0xbb, 0x3e, 0x07, 0x65, 0xd7, 0xb7, + 0xbd, 0xb6, 0x83, 0xad, 0x38, 0xa4, 0xc9, 0x15, 0x3f, 0x45, 0x93, 0x02, 0xb8, 0x49, 0x61, 0xfa, + 0x07, 0x30, 0x26, 0x77, 0xa0, 0xb8, 0x82, 0xfa, 0xdc, 0x7a, 0xa3, 0x62, 0xeb, 0x75, 0x1f, 0xff, + 0xe1, 0x93, 0x1d, 0xff, 0x8f, 0xa0, 0xc2, 0xd3, 0x2f, 0x8b, 0x04, 0x4c, 0x71, 0xa7, 0x3a, 0xd2, + 0x77, 0xe6, 0x56, 0xe6, 0xa4, 0xb7, 0x03, 0x6a, 0x9d, 0x63, 0x7c, 0xa9, 0xc1, 0x2c, 0xf3, 0xc9, + 0xd5, 0x20, 0xda, 0x0a, 0x88, 0xeb, 0xef, 0x49, 0xe7, 0xbc, 0x0c, 0x33, 0xfb, 0x01, 0x41, 0x3b, + 0x1e, 0xb6, 0x10, 0xc9, 0x2f, 0x5d, 0x45, 0x4c, 0xac, 0x11, 0xb1, 0x12, 0x5d, 0x16, 0x0e, 0x9d, + 0x2c, 0x98, 0x7e, 0xa3, 0xc1, 0xd4, 0x5d, 0x97, 0xf8, 0x99, 0x18, 0xfa, 0x29, 0x4c, 0xfb, 0x01, + 0xc1, 0x99, 0x54, 0x98, 0x66, 0x18, 0x43, 0x83, 0xe7, 0xc2, 0x15, 0xca, 0x26, 0x1d, 0xc7, 0x3d, + 0x2b, 0x87, 0x43, 0xa7, 0x57, 0x39, 0x34, 0x30, 0x54, 0x12, 0x5b, 0xc4, 0xf1, 0x30, 0x61, 0xb2, + 0xc3, 0x41, 0x3c, 0x41, 0x1d, 0xa0, 0xae, 0x26, 0x58, 0xb1, 0xfc, 0x74, 0xa2, 0x93, 0x0e, 0x8c, + 0xbf, 0x69, 0x30, 0x27, 0x26, 0xff, 0x33, 0x6b, 0xa3, 0x1e, 0xcc, 0x77, 0xd9, 0xf7, 0xf8, 0x2a, + 0xa3, 0x5f, 0x0f, 0x41, 0x99, 0x9d, 0xe4, 0x64, 0x07, 0xd6, 0x60, 0x8c, 0xdf, 0x40, 0x98, 0xe7, + 0x39, 0x63, 0x66, 0x32, 0xd6, 0x5d, 0x58, 0xc8, 0x44, 0x12, 0xdb, 0xdd, 0x75, 0x6d, 0xcb, 0xc1, + 0x7e, 0xd0, 0x72, 0x7d, 0x51, 0xca, 0xe1, 0x7b, 0xf5, 0x88, 0x4b, 0xe1, 0x0a, 0x25, 0x31, 0x9f, + 0x4c, 0xe3, 0x0f, 0xe3, 0x74, 0x25, 0xcb, 0x48, 0x5f, 0x85, 0xf3, 0x52, 0x54, 0x5a, 0xd7, 0xb1, + 0x48, 0x70, 0x1f, 0xfb, 0xb1, 0x88, 0xdc, 0xf3, 0x02, 0xe1, 0x4a, 0x32, 0x7f, 0x9b, 0x4d, 0xeb, + 0x6f, 0x41, 0x55, 0xd2, 0xb6, 0xfd, 0x9d, 0xc0, 0x67, 0xc9, 0xb5, 0x20, 0x1d, 0x66, 0xa4, 0x73, + 0x62, 0xfe, 0x8e, 0x9c, 0x16, 0x94, 0x2f, 0x40, 0x45, 0x52, 0x7a, 0xa1, 0xe5, 0xef, 0x92, 0xb8, + 0x7a, 0x86, 0x11, 0xc8, 0x08, 0xfa, 0x49, 0x78, 0x73, 0x97, 0xc4, 0xfa, 0x0a, 0xcc, 0x4a, 0xbc, + 0x30, 0x0a, 0xc2, 0x20, 0x46, 0x1e, 0xc7, 0x1e, 0x61, 0xd8, 0x67, 0xc5, 0xe4, 0x86, 0x98, 0x63, + 0x34, 0x6b, 0xf0, 0x94, 0xa4, 0xd9, 0x67, 0x21, 0xc8, 0x8a, 0xb0, 0x8d, 0xdd, 0x90, 0x48, 0xd5, + 0x46, 0x19, 0x6d, 0x4d, 0x20, 0xc9, 0x30, 0xc5, 0x50, 0xb8, 0x7a, 0x86, 0x03, 0x53, 0x72, 0xb1, + 0x92, 0x23, 0x36, 0xc5, 0x16, 0xc0, 0x6a, 0x61, 0x82, 0x32, 0xfb, 0xf1, 0x95, 0x3e, 0x56, 0xe0, + 0x86, 0x20, 0x31, 0xcb, 0x4e, 0x76, 0x68, 0xcc, 0xc1, 0xb9, 0xb5, 0x30, 0xdc, 0x40, 0x11, 0x6a, + 0x61, 0x82, 0xa3, 0xe4, 0xae, 0xde, 0x81, 0xd9, 0x02, 0x5c, 0x28, 0xb1, 0x0e, 0x10, 0x26, 0x50, + 0x45, 0x72, 0x81, 0xc2, 0x30, 0x73, 0x10, 0x72, 0x6c, 0x32, 0xc4, 0x86, 0x0e, 0xd3, 0xd7, 0x50, + 0xbc, 0x11, 0xb9, 0x69, 0xba, 0x65, 0xd8, 0x30, 0x93, 0x81, 0x25, 0x89, 0x2d, 0xec, 0xa1, 0xd8, + 0x0a, 0x19, 0x54, 0x71, 0x14, 0x14, 0xf5, 0x8c, 0x94, 0xd9, 0xf8, 0x9e, 0xfc, 0xa4, 0x46, 0x5f, + 0xbd, 0x71, 0xa5, 0xdb, 0x68, 0x1f, 0x66, 0x0b, 0x70, 0xa1, 0xc0, 0x9d, 0x1e, 0x46, 0xab, 0xcb, + 0x7f, 0xbc, 0xe1, 0x97, 0x96, 0x54, 0x5a, 0x8e, 0xc2, 0x01, 0xbf, 0xd5, 0x60, 0x9e, 0xde, 0x54, + 0x8d, 0xc3, 0x4c, 0x30, 0x17, 0x47, 0x73, 0x0b, 0x2a, 0x85, 0xcb, 0x41, 0xac, 0xf6, 0xa0, 0x75, + 0x92, 0xfc, 0xdd, 0xd0, 0xab, 0x57, 0x31, 0xd4, 0xb3, 0x57, 0xe1, 0x43, 0xb5, 0x5b, 0xb7, 0x74, + 0x27, 0xb2, 0x4b, 0x9a, 0x5d, 0xa5, 0x54, 0x80, 0xf0, 0xc9, 0x2b, 0xaa, 0xe2, 0xde, 0xa6, 0xc4, + 0xa6, 0x2c, 0x4d, 0x6c, 0x07, 0x91, 0x63, 0x96, 0xe3, 0x2c, 0x90, 0x39, 0x63, 0xb3, 0x83, 0x42, + 0x85, 0x33, 0x8a, 0x45, 0xa3, 0xd2, 0x29, 0x14, 0x8d, 0xfa, 0x77, 0x86, 0x09, 0xd5, 0x6e, 0xdd, + 0x84, 0x33, 0xde, 0x84, 0x61, 0xca, 0xb6, 0xbb, 0xd4, 0x54, 0x70, 0x41, 0x07, 0x85, 0xc2, 0x72, + 0x86, 0x6f, 0xcc, 0xc3, 0xec, 0x1d, 0x9f, 0x15, 0xca, 0xb0, 0x43, 0x27, 0x93, 0x6d, 0xb8, 0x01, + 0x73, 0xc5, 0x89, 0x13, 0x8a, 0xfa, 0x42, 0x83, 0xb9, 0x9b, 0x6d, 0xcf, 0x73, 0x77, 0x5d, 0x1c, + 0xe5, 0x92, 0x72, 0xfd, 0x06, 0x8c, 0xfb, 0x72, 0x46, 0x38, 0x55, 0x7d, 0xb4, 0xe2, 0xac, 0x73, + 0x13, 0x86, 0x66, 0xca, 0xa1, 0x7f, 0x8f, 0x2e, 0xc1, 0x7c, 0x97, 0x46, 0xc2, 0xca, 0x73, 0x70, + 0x86, 0xe7, 0xae, 0xfc, 0x4a, 0xe2, 0x03, 0xe3, 0x1e, 0x3c, 0x99, 0xed, 0x78, 0xf9, 0xbb, 0x41, + 0xe3, 0xf0, 0x3a, 0x8a, 0x9b, 0xd2, 0x10, 0xde, 0x3a, 0x2b, 0x1d, 0xaf, 0x75, 0x66, 0x6c, 0xc3, + 0x5c, 0x81, 0xbb, 0xe4, 0xfb, 0x2c, 0x4c, 0xc6, 0x04, 0x45, 0x85, 0x7c, 0x71, 0x82, 0xc1, 0x44, + 0xae, 0xf8, 0x14, 0x00, 0xf6, 0x9d, 0x7c, 0x66, 0x3f, 0x8e, 0x7d, 0x47, 0x24, 0xe9, 0x7f, 0x2f, + 0x41, 0xa5, 0xc0, 0x5c, 0x9f, 0x83, 0x91, 0x1c, 0x3f, 0x31, 0x3a, 0x99, 0x15, 0xc5, 0xa4, 0x61, + 0xe8, 0x14, 0x7a, 0x9b, 0xf7, 0x60, 0x22, 0xc4, 0x11, 0xcd, 0x00, 0x88, 0xbb, 0x2f, 0xdb, 0x6c, + 0xab, 0x83, 0xe6, 0x58, 0x29, 0x07, 0x33, 0xcb, 0x4e, 0xbf, 0x06, 0xc3, 0x74, 0xeb, 0xb2, 0x8b, + 0x77, 0xf0, 0xd4, 0x6d, 0xcb, 0xc5, 0x1d, 0x93, 0x31, 0x30, 0xfe, 0x0f, 0xe6, 0xbb, 0xd6, 0x4f, + 0x6c, 0xa7, 0x0f, 0x60, 0x94, 0x1c, 0x58, 0xae, 0xbf, 0x1b, 0x88, 0x73, 0xf3, 0x62, 0x1f, 0x2d, + 0x08, 0xc6, 0x61, 0x84, 0x1c, 0xd0, 0xbf, 0x06, 0x82, 0xa7, 0x14, 0x5b, 0xef, 0xd4, 0x44, 0x7c, + 0x06, 0x65, 0xf1, 0x8e, 0x13, 0x2c, 0x3f, 0x81, 0x09, 0x16, 0xff, 0x23, 0x76, 0x8e, 0x8f, 0x13, + 0x5f, 0xc1, 0x4f, 0xbe, 0x8d, 0x3f, 0xd2, 0x00, 0x50, 0x78, 0x13, 0x3d, 0x0e, 0x41, 0xfa, 0xc7, + 0x30, 0xe9, 0x3a, 0xd8, 0x27, 0x2e, 0x39, 0xb4, 0xee, 0xe3, 0x43, 0xb1, 0x93, 0x17, 0x1f, 0xf9, + 0x6a, 0x5a, 0x17, 0x04, 0x1f, 0xe3, 0x43, 0x73, 0xc2, 0x4d, 0x07, 0xc6, 0x2f, 0x86, 0xe1, 0x6c, + 0x0f, 0x81, 0xbd, 0xee, 0x46, 0xed, 0x34, 0xee, 0xc6, 0xeb, 0x30, 0xcc, 0x2e, 0x33, 0xae, 0xf4, + 0x25, 0x75, 0x18, 0xcc, 0xfd, 0xaa, 0x25, 0x0d, 0x88, 0x54, 0x43, 0xc6, 0xe1, 0xb4, 0x5f, 0x8f, + 0xf9, 0x28, 0x3d, 0x7c, 0xe2, 0x28, 0x7d, 0x01, 0xa6, 0x78, 0xbc, 0xb1, 0xec, 0x08, 0x23, 0x82, + 0x1d, 0x76, 0x00, 0x87, 0xcd, 0x32, 0x87, 0x5e, 0xe6, 0x40, 0x1a, 0xfa, 0x04, 0x1a, 0x8f, 0xc7, + 0x23, 0x3c, 0xf4, 0x71, 0x18, 0x2f, 0x25, 0xd4, 0x32, 0x5d, 0x83, 0x51, 0x36, 0x9d, 0x8c, 0xf5, + 0x9b, 0x49, 0x73, 0x7e, 0x8c, 0x69, 0xfc, 0x66, 0x7f, 0x1a, 0xa7, 0x0b, 0xb2, 0xc9, 0xa8, 0x65, + 0xa7, 0xde, 0xf8, 0xe7, 0x10, 0x40, 0x7a, 0xb5, 0x3d, 0xae, 0x4e, 0x12, 0x8d, 0x49, 0xec, 0x92, + 0x2d, 0xf5, 0x8c, 0x49, 0x8a, 0xe2, 0x3c, 0xd5, 0x2b, 0xf3, 0xe3, 0x04, 0xca, 0x20, 0xe7, 0x9b, + 0xa1, 0x82, 0x6f, 0x4e, 0x79, 0x41, 0xb7, 0x61, 0x82, 0xff, 0xf6, 0x80, 0xbf, 0x53, 0x79, 0x38, + 0x7d, 0xbb, 0x3f, 0xd5, 0x1b, 0x88, 0xd8, 0x4d, 0xaa, 0x3f, 0xef, 0x9f, 0xb2, 0xb7, 0x2a, 0x04, + 0xc9, 0x77, 0x76, 0xb3, 0xf0, 0x9c, 0x44, 0xec, 0x03, 0xb9, 0x59, 0x38, 0x30, 0xb3, 0xda, 0xa3, + 0xa7, 0xb2, 0xda, 0x7f, 0xd1, 0x60, 0xfe, 0x56, 0xc7, 0xc7, 0x4e, 0xda, 0x97, 0x49, 0x92, 0x96, + 0xed, 0x4c, 0xc7, 0x3c, 0xa6, 0xcb, 0xa9, 0x78, 0xfb, 0x1f, 0xd1, 0xe9, 0x61, 0x3b, 0x21, 0x6d, + 0x93, 0xb3, 0x61, 0x57, 0x8f, 0xa6, 0x74, 0x2a, 0x3d, 0x9a, 0x16, 0x54, 0xbb, 0x8d, 0x49, 0x9f, + 0xfa, 0xa7, 0xdc, 0xb4, 0x5a, 0xf9, 0xd7, 0x2c, 0x9c, 0xa5, 0xb7, 0xe3, 0x46, 0x14, 0x90, 0xc0, + 0x0e, 0xbc, 0x4d, 0x1c, 0xed, 0xbb, 0x36, 0xd6, 0xef, 0xc2, 0x08, 0x4f, 0xb6, 0xf4, 0x0b, 0xca, + 0x08, 0x9f, 0x4d, 0x0f, 0x6b, 0x2f, 0x1c, 0x85, 0x26, 0x6c, 0xb8, 0x0f, 0x93, 0xd9, 0xaa, 0xa9, + 0xfe, 0xca, 0xa3, 0xe9, 0x72, 0x35, 0xd7, 0xda, 0xab, 0xfd, 0x21, 0x73, 0x51, 0xcb, 0x9a, 0xbe, + 0x05, 0x67, 0xd8, 0x65, 0xa6, 0x3f, 0xaf, 0x22, 0xcc, 0xd6, 0x44, 0x6b, 0x17, 0x8e, 0xc0, 0x4a, + 0xf8, 0x3e, 0x80, 0xa9, 0xfc, 0x25, 0xa9, 0xbf, 0xf6, 0x48, 0xd2, 0x62, 0x81, 0xb1, 0x56, 0xef, + 0x17, 0x3d, 0x11, 0xb9, 0x0d, 0xa3, 0xa2, 0x02, 0xa4, 0x2b, 0x5d, 0x9d, 0x2f, 0x1b, 0xd6, 0x5e, + 0x3c, 0x12, 0x4f, 0xac, 0x49, 0x94, 0x54, 0xe9, 0x64, 0x75, 0x49, 0xaf, 0x1f, 0x41, 0x5b, 0x28, + 0xb3, 0xd5, 0x96, 0xfa, 0xc6, 0x17, 0x32, 0xff, 0x17, 0x46, 0x78, 0xd5, 0x42, 0xbd, 0xc1, 0x72, + 0x25, 0x28, 0xf5, 0x06, 0xcb, 0x17, 0x3f, 0x96, 0x35, 0xdd, 0x83, 0x72, 0xae, 0x96, 0xa0, 0x2b, + 0xb7, 0x4d, 0xaf, 0x8a, 0x46, 0xed, 0xb5, 0x3e, 0xb1, 0x85, 0x21, 0x3f, 0x80, 0xf1, 0xa4, 0x76, + 0xa0, 0x2f, 0xaa, 0x68, 0x8b, 0xf5, 0x8b, 0xda, 0x4b, 0x7d, 0x60, 0x0a, 0x09, 0x1e, 0x94, 0x73, + 0xd5, 0x06, 0xb5, 0x3d, 0xbd, 0x8a, 0x15, 0x6a, 0x7b, 0x7a, 0x97, 0x30, 0x02, 0x98, 0xca, 0x37, + 0x55, 0xd5, 0x7b, 0xbb, 0x67, 0x97, 0x57, 0xbd, 0xb7, 0x15, 0xbd, 0xda, 0xcf, 0x60, 0x4c, 0xb6, + 0x45, 0x75, 0xf5, 0x96, 0xcd, 0x77, 0x63, 0x6b, 0x8b, 0x47, 0x23, 0xa6, 0xf6, 0xe4, 0xdb, 0xa0, + 0x6a, 0x7b, 0x7a, 0xf6, 0x61, 0xd5, 0xf6, 0x28, 0xba, 0xab, 0x6d, 0x98, 0x2e, 0x36, 0x1e, 0x75, + 0xe5, 0xf1, 0x50, 0xb4, 0x4d, 0x6b, 0xcb, 0xfd, 0x13, 0x08, 0xb1, 0x16, 0x8c, 0xc9, 0xee, 0x9e, + 0xda, 0x8d, 0x85, 0xa6, 0xa5, 0xda, 0x8d, 0xc5, 0x46, 0xe1, 0xb2, 0x46, 0xed, 0x2a, 0xd6, 0x79, + 0xd4, 0x76, 0x29, 0xaa, 0x55, 0x6a, 0xbb, 0x94, 0x25, 0xa4, 0x36, 0x4c, 0x17, 0x2b, 0x2a, 0x6a, + 0xb1, 0x8a, 0xba, 0x90, 0x5a, 0xac, 0xb2, 0x58, 0xf3, 0x00, 0xa6, 0xf2, 0xb5, 0x15, 0xf5, 0xb6, + 0xe9, 0x59, 0x9c, 0x51, 0x6f, 0x9b, 0xde, 0x25, 0x9b, 0x65, 0x8d, 0x86, 0xe1, 0x42, 0xa5, 0x43, + 0x1d, 0x86, 0x7b, 0x17, 0x69, 0xd4, 0x61, 0x58, 0x55, 0x42, 0xf9, 0xa9, 0x06, 0xb3, 0x3d, 0x9f, + 0xac, 0xfa, 0xa5, 0x3e, 0x5f, 0xa6, 0xb9, 0xe2, 0x4a, 0xed, 0x8d, 0x01, 0xa9, 0x84, 0x1a, 0xa4, + 0xbb, 0xf0, 0x51, 0xef, 0xf7, 0x65, 0x7c, 0x94, 0xe9, 0x8a, 0xe7, 0xfe, 0xb2, 0xa6, 0xff, 0x08, + 0xf4, 0xee, 0xdf, 0xc3, 0xe8, 0x17, 0x07, 0xfe, 0xe1, 0x61, 0x6d, 0x65, 0x10, 0x12, 0x61, 0xf2, + 0x8f, 0x35, 0x38, 0xd7, 0xeb, 0x27, 0xde, 0xfa, 0xeb, 0xca, 0x33, 0xa9, 0xfe, 0xb1, 0x7a, 0xed, + 0xd2, 0x60, 0x44, 0x42, 0x87, 0x0e, 0x4c, 0x17, 0x93, 0x4d, 0xf5, 0xd9, 0x52, 0xe4, 0xd8, 0xea, + 0xb3, 0xa5, 0xca, 0x63, 0x97, 0x35, 0xfd, 0x00, 0x66, 0xba, 0x7e, 0xeb, 0xaf, 0x2b, 0x19, 0xa9, + 0xfe, 0xf1, 0xa1, 0x76, 0x71, 0x00, 0x0a, 0x2e, 0xbb, 0xf1, 0xb3, 0xd2, 0x9f, 0x1e, 0x2e, 0x68, + 0xdf, 0x3e, 0x5c, 0xd0, 0xbe, 0x7b, 0xb8, 0xa0, 0x7d, 0xf1, 0xfd, 0xc2, 0x13, 0xdf, 0x7e, 0xbf, + 0xf0, 0xc4, 0x5f, 0xbf, 0x5f, 0x78, 0x02, 0x6a, 0x76, 0xd0, 0x52, 0x30, 0x6c, 0x8c, 0x27, 0x49, + 0xf2, 0x86, 0xb6, 0x7d, 0x6b, 0xcf, 0x25, 0xcd, 0xf6, 0x0e, 0x4d, 0xb5, 0x97, 0xec, 0x20, 0x6e, + 0x05, 0xf1, 0x12, 0xfb, 0x4d, 0x31, 0x8e, 0x96, 0xf6, 0x57, 0x92, 0x4f, 0x56, 0xdd, 0x8f, 0x97, + 0x7a, 0xff, 0x1f, 0xd2, 0x3b, 0x74, 0x24, 0x07, 0xbf, 0x2b, 0x0d, 0x6d, 0x6c, 0x7d, 0xfa, 0xfb, + 0xd2, 0xdc, 0x86, 0x14, 0x4e, 0xa5, 0xd5, 0xb7, 0xc4, 0xf4, 0x37, 0xe9, 0xc4, 0x3d, 0x3a, 0x71, + 0x4f, 0x4e, 0x3c, 0x2c, 0x19, 0xbd, 0x27, 0xee, 0x5d, 0xdb, 0x68, 0xc8, 0xce, 0xcd, 0x3f, 0x4a, + 0x55, 0x89, 0xb4, 0xba, 0x4a, 0xb1, 0x56, 0x57, 0x25, 0xda, 0xce, 0x08, 0xfb, 0xe7, 0x92, 0xd7, + 0xff, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xeb, 0x61, 0x26, 0xe8, 0x2d, 0x35, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -3743,10 +3587,10 @@ const _ = grpc.SupportPackageIsVersion4 type ViewProtocolServiceClient interface { // Get current status of chain sync Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) - // Stream sync status updates until the view service has caught up with the core.chain.v1alpha1. + // Stream sync status updates until the view service has caught up with the chain. // Returns a stream of `StatusStreamResponse`s. StatusStream(ctx context.Context, in *StatusStreamRequest, opts ...grpc.CallOption) (ViewProtocolService_StatusStreamClient, error) - // Queries for notes that have been accepted by the core.chain.v1alpha1. + // Queries for notes that have been accepted by the chain. // Returns a stream of `NotesResponse`s. Notes(ctx context.Context, in *NotesRequest, opts ...grpc.CallOption) (ViewProtocolService_NotesClient, error) // Returns a stream of `NotesForVotingResponse`s. @@ -3762,12 +3606,16 @@ type ViewProtocolServiceClient interface { // Queries for assets. // Returns a stream of `AssetsResponse`s. Assets(ctx context.Context, in *AssetsRequest, opts ...grpc.CallOption) (ViewProtocolService_AssetsClient, error) - // Query for the current chain parameters. - ChainParameters(ctx context.Context, in *ChainParametersRequest, opts ...grpc.CallOption) (*ChainParametersResponse, error) + // Query for the current app parameters. + AppParameters(ctx context.Context, in *AppParametersRequest, opts ...grpc.CallOption) (*AppParametersResponse, error) + // Query for the current gas prices. + GasPrices(ctx context.Context, in *GasPricesRequest, opts ...grpc.CallOption) (*GasPricesResponse, error) // Query for the current FMD parameters. FMDParameters(ctx context.Context, in *FMDParametersRequest, opts ...grpc.CallOption) (*FMDParametersResponse, error) // Query for an address given an address index AddressByIndex(ctx context.Context, in *AddressByIndexRequest, opts ...grpc.CallOption) (*AddressByIndexResponse, error) + // Query for wallet id + WalletId(ctx context.Context, in *WalletIdRequest, opts ...grpc.CallOption) (*WalletIdResponse, error) // Query for an address given an address index IndexByAddress(ctx context.Context, in *IndexByAddressRequest, opts ...grpc.CallOption) (*IndexByAddressResponse, error) // Query for an ephemeral address @@ -3779,6 +3627,8 @@ type ViewProtocolServiceClient interface { NoteByCommitment(ctx context.Context, in *NoteByCommitmentRequest, opts ...grpc.CallOption) (*NoteByCommitmentResponse, error) // Query for a swap by its swap commitment, optionally waiting until the swap is detected. SwapByCommitment(ctx context.Context, in *SwapByCommitmentRequest, opts ...grpc.CallOption) (*SwapByCommitmentResponse, error) + // Query for all unclaimed swaps. + UnclaimedSwaps(ctx context.Context, in *UnclaimedSwapsRequest, opts ...grpc.CallOption) (ViewProtocolService_UnclaimedSwapsClient, error) // Query for whether a nullifier has been spent, optionally waiting until it is spent. NullifierStatus(ctx context.Context, in *NullifierStatusRequest, opts ...grpc.CallOption) (*NullifierStatusResponse, error) // Query for a given transaction by its hash. @@ -3959,9 +3809,18 @@ func (x *viewProtocolServiceAssetsClient) Recv() (*AssetsResponse, error) { return m, nil } -func (c *viewProtocolServiceClient) ChainParameters(ctx context.Context, in *ChainParametersRequest, opts ...grpc.CallOption) (*ChainParametersResponse, error) { - out := new(ChainParametersResponse) - err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/ChainParameters", in, out, opts...) +func (c *viewProtocolServiceClient) AppParameters(ctx context.Context, in *AppParametersRequest, opts ...grpc.CallOption) (*AppParametersResponse, error) { + out := new(AppParametersResponse) + err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/AppParameters", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *viewProtocolServiceClient) GasPrices(ctx context.Context, in *GasPricesRequest, opts ...grpc.CallOption) (*GasPricesResponse, error) { + out := new(GasPricesResponse) + err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/GasPrices", in, out, opts...) if err != nil { return nil, err } @@ -3986,6 +3845,15 @@ func (c *viewProtocolServiceClient) AddressByIndex(ctx context.Context, in *Addr return out, nil } +func (c *viewProtocolServiceClient) WalletId(ctx context.Context, in *WalletIdRequest, opts ...grpc.CallOption) (*WalletIdResponse, error) { + out := new(WalletIdResponse) + err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/WalletId", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *viewProtocolServiceClient) IndexByAddress(ctx context.Context, in *IndexByAddressRequest, opts ...grpc.CallOption) (*IndexByAddressResponse, error) { out := new(IndexByAddressResponse) err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/IndexByAddress", in, out, opts...) @@ -4054,6 +3922,38 @@ func (c *viewProtocolServiceClient) SwapByCommitment(ctx context.Context, in *Sw return out, nil } +func (c *viewProtocolServiceClient) UnclaimedSwaps(ctx context.Context, in *UnclaimedSwapsRequest, opts ...grpc.CallOption) (ViewProtocolService_UnclaimedSwapsClient, error) { + stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[5], "/penumbra.view.v1alpha1.ViewProtocolService/UnclaimedSwaps", opts...) + if err != nil { + return nil, err + } + x := &viewProtocolServiceUnclaimedSwapsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type ViewProtocolService_UnclaimedSwapsClient interface { + Recv() (*UnclaimedSwapsResponse, error) + grpc.ClientStream +} + +type viewProtocolServiceUnclaimedSwapsClient struct { + grpc.ClientStream +} + +func (x *viewProtocolServiceUnclaimedSwapsClient) Recv() (*UnclaimedSwapsResponse, error) { + m := new(UnclaimedSwapsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + func (c *viewProtocolServiceClient) NullifierStatus(ctx context.Context, in *NullifierStatusRequest, opts ...grpc.CallOption) (*NullifierStatusResponse, error) { out := new(NullifierStatusResponse) err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/NullifierStatus", in, out, opts...) @@ -4073,7 +3973,7 @@ func (c *viewProtocolServiceClient) TransactionInfoByHash(ctx context.Context, i } func (c *viewProtocolServiceClient) TransactionInfo(ctx context.Context, in *TransactionInfoRequest, opts ...grpc.CallOption) (ViewProtocolService_TransactionInfoClient, error) { - stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[5], "/penumbra.view.v1alpha1.ViewProtocolService/TransactionInfo", opts...) + stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[6], "/penumbra.view.v1alpha1.ViewProtocolService/TransactionInfo", opts...) if err != nil { return nil, err } @@ -4123,7 +4023,7 @@ func (c *viewProtocolServiceClient) BroadcastTransaction(ctx context.Context, in } func (c *viewProtocolServiceClient) OwnedPositionIds(ctx context.Context, in *OwnedPositionIdsRequest, opts ...grpc.CallOption) (ViewProtocolService_OwnedPositionIdsClient, error) { - stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[6], "/penumbra.view.v1alpha1.ViewProtocolService/OwnedPositionIds", opts...) + stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[7], "/penumbra.view.v1alpha1.ViewProtocolService/OwnedPositionIds", opts...) if err != nil { return nil, err } @@ -4167,10 +4067,10 @@ func (c *viewProtocolServiceClient) AuthorizeAndBuild(ctx context.Context, in *A type ViewProtocolServiceServer interface { // Get current status of chain sync Status(context.Context, *StatusRequest) (*StatusResponse, error) - // Stream sync status updates until the view service has caught up with the core.chain.v1alpha1. + // Stream sync status updates until the view service has caught up with the chain. // Returns a stream of `StatusStreamResponse`s. StatusStream(*StatusStreamRequest, ViewProtocolService_StatusStreamServer) error - // Queries for notes that have been accepted by the core.chain.v1alpha1. + // Queries for notes that have been accepted by the chain. // Returns a stream of `NotesResponse`s. Notes(*NotesRequest, ViewProtocolService_NotesServer) error // Returns a stream of `NotesForVotingResponse`s. @@ -4186,12 +4086,16 @@ type ViewProtocolServiceServer interface { // Queries for assets. // Returns a stream of `AssetsResponse`s. Assets(*AssetsRequest, ViewProtocolService_AssetsServer) error - // Query for the current chain parameters. - ChainParameters(context.Context, *ChainParametersRequest) (*ChainParametersResponse, error) + // Query for the current app parameters. + AppParameters(context.Context, *AppParametersRequest) (*AppParametersResponse, error) + // Query for the current gas prices. + GasPrices(context.Context, *GasPricesRequest) (*GasPricesResponse, error) // Query for the current FMD parameters. FMDParameters(context.Context, *FMDParametersRequest) (*FMDParametersResponse, error) // Query for an address given an address index AddressByIndex(context.Context, *AddressByIndexRequest) (*AddressByIndexResponse, error) + // Query for wallet id + WalletId(context.Context, *WalletIdRequest) (*WalletIdResponse, error) // Query for an address given an address index IndexByAddress(context.Context, *IndexByAddressRequest) (*IndexByAddressResponse, error) // Query for an ephemeral address @@ -4203,6 +4107,8 @@ type ViewProtocolServiceServer interface { NoteByCommitment(context.Context, *NoteByCommitmentRequest) (*NoteByCommitmentResponse, error) // Query for a swap by its swap commitment, optionally waiting until the swap is detected. SwapByCommitment(context.Context, *SwapByCommitmentRequest) (*SwapByCommitmentResponse, error) + // Query for all unclaimed swaps. + UnclaimedSwaps(*UnclaimedSwapsRequest, ViewProtocolService_UnclaimedSwapsServer) error // Query for whether a nullifier has been spent, optionally waiting until it is spent. NullifierStatus(context.Context, *NullifierStatusRequest) (*NullifierStatusResponse, error) // Query for a given transaction by its hash. @@ -4245,8 +4151,11 @@ func (*UnimplementedViewProtocolServiceServer) WitnessAndBuild(ctx context.Conte func (*UnimplementedViewProtocolServiceServer) Assets(req *AssetsRequest, srv ViewProtocolService_AssetsServer) error { return status.Errorf(codes.Unimplemented, "method Assets not implemented") } -func (*UnimplementedViewProtocolServiceServer) ChainParameters(ctx context.Context, req *ChainParametersRequest) (*ChainParametersResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ChainParameters not implemented") +func (*UnimplementedViewProtocolServiceServer) AppParameters(ctx context.Context, req *AppParametersRequest) (*AppParametersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AppParameters not implemented") +} +func (*UnimplementedViewProtocolServiceServer) GasPrices(ctx context.Context, req *GasPricesRequest) (*GasPricesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GasPrices not implemented") } func (*UnimplementedViewProtocolServiceServer) FMDParameters(ctx context.Context, req *FMDParametersRequest) (*FMDParametersResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method FMDParameters not implemented") @@ -4254,6 +4163,9 @@ func (*UnimplementedViewProtocolServiceServer) FMDParameters(ctx context.Context func (*UnimplementedViewProtocolServiceServer) AddressByIndex(ctx context.Context, req *AddressByIndexRequest) (*AddressByIndexResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AddressByIndex not implemented") } +func (*UnimplementedViewProtocolServiceServer) WalletId(ctx context.Context, req *WalletIdRequest) (*WalletIdResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WalletId not implemented") +} func (*UnimplementedViewProtocolServiceServer) IndexByAddress(ctx context.Context, req *IndexByAddressRequest) (*IndexByAddressResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method IndexByAddress not implemented") } @@ -4269,6 +4181,9 @@ func (*UnimplementedViewProtocolServiceServer) NoteByCommitment(ctx context.Cont func (*UnimplementedViewProtocolServiceServer) SwapByCommitment(ctx context.Context, req *SwapByCommitmentRequest) (*SwapByCommitmentResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SwapByCommitment not implemented") } +func (*UnimplementedViewProtocolServiceServer) UnclaimedSwaps(req *UnclaimedSwapsRequest, srv ViewProtocolService_UnclaimedSwapsServer) error { + return status.Errorf(codes.Unimplemented, "method UnclaimedSwaps not implemented") +} func (*UnimplementedViewProtocolServiceServer) NullifierStatus(ctx context.Context, req *NullifierStatusRequest) (*NullifierStatusResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method NullifierStatus not implemented") } @@ -4433,20 +4348,38 @@ func (x *viewProtocolServiceAssetsServer) Send(m *AssetsResponse) error { return x.ServerStream.SendMsg(m) } -func _ViewProtocolService_ChainParameters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ChainParametersRequest) +func _ViewProtocolService_AppParameters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AppParametersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ViewProtocolServiceServer).AppParameters(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/AppParameters", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ViewProtocolServiceServer).AppParameters(ctx, req.(*AppParametersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ViewProtocolService_GasPrices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GasPricesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(ViewProtocolServiceServer).ChainParameters(ctx, in) + return srv.(ViewProtocolServiceServer).GasPrices(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/ChainParameters", + FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/GasPrices", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(ViewProtocolServiceServer).ChainParameters(ctx, req.(*ChainParametersRequest)) + return srv.(ViewProtocolServiceServer).GasPrices(ctx, req.(*GasPricesRequest)) } return interceptor(ctx, in, info, handler) } @@ -4487,6 +4420,24 @@ func _ViewProtocolService_AddressByIndex_Handler(srv interface{}, ctx context.Co return interceptor(ctx, in, info, handler) } +func _ViewProtocolService_WalletId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(WalletIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ViewProtocolServiceServer).WalletId(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/WalletId", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ViewProtocolServiceServer).WalletId(ctx, req.(*WalletIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ViewProtocolService_IndexByAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(IndexByAddressRequest) if err := dec(in); err != nil { @@ -4580,6 +4531,27 @@ func _ViewProtocolService_SwapByCommitment_Handler(srv interface{}, ctx context. return interceptor(ctx, in, info, handler) } +func _ViewProtocolService_UnclaimedSwaps_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(UnclaimedSwapsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(ViewProtocolServiceServer).UnclaimedSwaps(m, &viewProtocolServiceUnclaimedSwapsServer{stream}) +} + +type ViewProtocolService_UnclaimedSwapsServer interface { + Send(*UnclaimedSwapsResponse) error + grpc.ServerStream +} + +type viewProtocolServiceUnclaimedSwapsServer struct { + grpc.ServerStream +} + +func (x *viewProtocolServiceUnclaimedSwapsServer) Send(m *UnclaimedSwapsResponse) error { + return x.ServerStream.SendMsg(m) +} + func _ViewProtocolService_NullifierStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(NullifierStatusRequest) if err := dec(in); err != nil { @@ -4729,8 +4701,12 @@ var _ViewProtocolService_serviceDesc = grpc.ServiceDesc{ Handler: _ViewProtocolService_WitnessAndBuild_Handler, }, { - MethodName: "ChainParameters", - Handler: _ViewProtocolService_ChainParameters_Handler, + MethodName: "AppParameters", + Handler: _ViewProtocolService_AppParameters_Handler, + }, + { + MethodName: "GasPrices", + Handler: _ViewProtocolService_GasPrices_Handler, }, { MethodName: "FMDParameters", @@ -4740,6 +4716,10 @@ var _ViewProtocolService_serviceDesc = grpc.ServiceDesc{ MethodName: "AddressByIndex", Handler: _ViewProtocolService_AddressByIndex_Handler, }, + { + MethodName: "WalletId", + Handler: _ViewProtocolService_WalletId_Handler, + }, { MethodName: "IndexByAddress", Handler: _ViewProtocolService_IndexByAddress_Handler, @@ -4803,6 +4783,11 @@ var _ViewProtocolService_serviceDesc = grpc.ServiceDesc{ Handler: _ViewProtocolService_Balances_Handler, ServerStreams: true, }, + { + StreamName: "UnclaimedSwaps", + Handler: _ViewProtocolService_UnclaimedSwaps_Handler, + ServerStreams: true, + }, { StreamName: "TransactionInfo", Handler: _ViewProtocolService_TransactionInfo_Handler, @@ -4817,78 +4802,6 @@ var _ViewProtocolService_serviceDesc = grpc.ServiceDesc{ Metadata: "penumbra/view/v1alpha1/view.proto", } -// ViewAuthServiceClient is the client API for ViewAuthService service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type ViewAuthServiceClient interface { - ViewAuth(ctx context.Context, in *ViewAuthRequest, opts ...grpc.CallOption) (*ViewAuthResponse, error) -} - -type viewAuthServiceClient struct { - cc grpc1.ClientConn -} - -func NewViewAuthServiceClient(cc grpc1.ClientConn) ViewAuthServiceClient { - return &viewAuthServiceClient{cc} -} - -func (c *viewAuthServiceClient) ViewAuth(ctx context.Context, in *ViewAuthRequest, opts ...grpc.CallOption) (*ViewAuthResponse, error) { - out := new(ViewAuthResponse) - err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewAuthService/ViewAuth", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -// ViewAuthServiceServer is the server API for ViewAuthService service. -type ViewAuthServiceServer interface { - ViewAuth(context.Context, *ViewAuthRequest) (*ViewAuthResponse, error) -} - -// UnimplementedViewAuthServiceServer can be embedded to have forward compatible implementations. -type UnimplementedViewAuthServiceServer struct { -} - -func (*UnimplementedViewAuthServiceServer) ViewAuth(ctx context.Context, req *ViewAuthRequest) (*ViewAuthResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ViewAuth not implemented") -} - -func RegisterViewAuthServiceServer(s grpc1.Server, srv ViewAuthServiceServer) { - s.RegisterService(&_ViewAuthService_serviceDesc, srv) -} - -func _ViewAuthService_ViewAuth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ViewAuthRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(ViewAuthServiceServer).ViewAuth(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/penumbra.view.v1alpha1.ViewAuthService/ViewAuth", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(ViewAuthServiceServer).ViewAuth(ctx, req.(*ViewAuthRequest)) - } - return interceptor(ctx, in, info, handler) -} - -var _ViewAuthService_serviceDesc = grpc.ServiceDesc{ - ServiceName: "penumbra.view.v1alpha1.ViewAuthService", - HandlerType: (*ViewAuthServiceServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "ViewAuth", - Handler: _ViewAuthService_ViewAuth_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "penumbra/view/v1alpha1/view.proto", -} - func (m *AuthorizeAndBuildRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -5076,10 +4989,74 @@ func (m *TransactionPlannerRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro _ = i var l int _ = l - if len(m.IbcActions) > 0 { - for iNdEx := len(m.IbcActions) - 1; iNdEx >= 0; iNdEx-- { + if len(m.PositionWithdraws) > 0 { + for iNdEx := len(m.PositionWithdraws) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PositionWithdraws[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xc2 + } + } + if len(m.PositionCloses) > 0 { + for iNdEx := len(m.PositionCloses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PositionCloses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xba + } + } + if len(m.PositionOpens) > 0 { + for iNdEx := len(m.PositionOpens) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PositionOpens[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + } + } + if len(m.Ics20Withdrawals) > 0 { + for iNdEx := len(m.Ics20Withdrawals) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.IbcActions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Ics20Withdrawals[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xea + } + } + if len(m.IbcRelayActions) > 0 { + for iNdEx := len(m.IbcRelayActions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.IbcRelayActions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5172,14 +5149,17 @@ func (m *TransactionPlannerRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro dAtA[i] = 0xa2 } } - if m.XAccountGroupId != nil { + if m.Source != nil { { - size := m.XAccountGroupId.Size() - i -= size - if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil { + size, err := m.Source.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { return 0, err } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x22 } if m.Memo != nil { { @@ -5213,27 +5193,6 @@ func (m *TransactionPlannerRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro return len(dAtA) - i, nil } -func (m *TransactionPlannerRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TransactionPlannerRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 - } - return len(dAtA) - i, nil -} func (m *TransactionPlannerRequest_Output) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -5301,6 +5260,18 @@ func (m *TransactionPlannerRequest_Swap) MarshalToSizedBuffer(dAtA []byte) (int, _ = i var l int _ = l + if m.ClaimAddress != nil { + { + size, err := m.ClaimAddress.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } if m.Fee != nil { { size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i]) @@ -5469,7 +5440,7 @@ func (m *TransactionPlannerRequest_Undelegate) MarshalToSizedBuffer(dAtA []byte) return len(dAtA) - i, nil } -func (m *TransactionPlannerResponse) Marshal() (dAtA []byte, err error) { +func (m *TransactionPlannerRequest_PositionOpen) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5479,19 +5450,19 @@ func (m *TransactionPlannerResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TransactionPlannerResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *TransactionPlannerRequest_PositionOpen) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TransactionPlannerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TransactionPlannerRequest_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Plan != nil { + if m.Position != nil { { - size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Position.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5504,7 +5475,7 @@ func (m *TransactionPlannerResponse) MarshalToSizedBuffer(dAtA []byte) (int, err return len(dAtA) - i, nil } -func (m *AddressByIndexRequest) Marshal() (dAtA []byte, err error) { +func (m *TransactionPlannerRequest_PositionClose) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5514,29 +5485,19 @@ func (m *AddressByIndexRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *AddressByIndexRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *TransactionPlannerRequest_PositionClose) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AddressByIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TransactionPlannerRequest_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DisplayConfirm { - i-- - if m.DisplayConfirm { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x10 - } - if m.AddressIndex != nil { + if m.PositionId != nil { { - size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5549,7 +5510,7 @@ func (m *AddressByIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *AddressByIndexResponse) Marshal() (dAtA []byte, err error) { +func (m *TransactionPlannerRequest_PositionWithdraw) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5559,19 +5520,43 @@ func (m *AddressByIndexResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *AddressByIndexResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *TransactionPlannerRequest_PositionWithdraw) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AddressByIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TransactionPlannerRequest_PositionWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Address != nil { + if m.TradingPair != nil { { - size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Reserves != nil { + { + size, err := m.Reserves.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PositionId != nil { + { + size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5584,7 +5569,7 @@ func (m *AddressByIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *IndexByAddressRequest) Marshal() (dAtA []byte, err error) { +func (m *TransactionPlannerResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5594,19 +5579,19 @@ func (m *IndexByAddressRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *IndexByAddressRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *TransactionPlannerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *IndexByAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TransactionPlannerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Address != nil { + if m.Plan != nil { { - size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5619,7 +5604,7 @@ func (m *IndexByAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *IndexByAddressResponse) Marshal() (dAtA []byte, err error) { +func (m *AddressByIndexRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5629,38 +5614,54 @@ func (m *IndexByAddressResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *IndexByAddressResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *AddressByIndexRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *IndexByAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AddressByIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.XAddressIndex != nil { + if m.AddressIndex != nil { { - size := m.XAddressIndex.Size() - i -= size - if _, err := m.XAddressIndex.MarshalTo(dAtA[i:]); err != nil { + size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { return 0, err } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *IndexByAddressResponse_AddressIndex) MarshalTo(dAtA []byte) (int, error) { +func (m *AddressByIndexResponse) 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 *AddressByIndexResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *IndexByAddressResponse_AddressIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AddressByIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.AddressIndex != nil { + _ = i + var l int + _ = l + if m.Address != nil { { - size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5672,7 +5673,8 @@ func (m *IndexByAddressResponse_AddressIndex) MarshalToSizedBuffer(dAtA []byte) } return len(dAtA) - i, nil } -func (m *EphemeralAddressRequest) Marshal() (dAtA []byte, err error) { + +func (m *WalletIdRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5682,29 +5684,42 @@ func (m *EphemeralAddressRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *EphemeralAddressRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *WalletIdRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *EphemeralAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *WalletIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DisplayConfirm { - i-- - if m.DisplayConfirm { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x10 + return len(dAtA) - i, nil +} + +func (m *WalletIdResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - if m.AddressIndex != nil { + return dAtA[:n], nil +} + +func (m *WalletIdResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WalletIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.WalletId != nil { { - size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.WalletId.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5717,7 +5732,7 @@ func (m *EphemeralAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *EphemeralAddressResponse) Marshal() (dAtA []byte, err error) { +func (m *IndexByAddressRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5727,12 +5742,12 @@ func (m *EphemeralAddressResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *EphemeralAddressResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *IndexByAddressRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *EphemeralAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *IndexByAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5752,7 +5767,7 @@ func (m *EphemeralAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error return len(dAtA) - i, nil } -func (m *BalancesRequest) Marshal() (dAtA []byte, err error) { +func (m *IndexByAddressResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5762,31 +5777,19 @@ func (m *BalancesRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *BalancesRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *IndexByAddressResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BalancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *IndexByAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.AssetIdFilter != nil { - { - size, err := m.AssetIdFilter.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.AccountFilter != nil { + if m.AddressIndex != nil { { - size, err := m.AccountFilter.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5799,7 +5802,7 @@ func (m *BalancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *BalancesResponse) Marshal() (dAtA []byte, err error) { +func (m *EphemeralAddressRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5809,31 +5812,29 @@ func (m *BalancesResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *BalancesResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *EphemeralAddressRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BalancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *EphemeralAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Balance != nil { - { - size, err := m.Balance.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) + if m.DisplayConfirm { + i-- + if m.DisplayConfirm { + dAtA[i] = 1 + } else { + dAtA[i] = 0 } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x10 } - if m.Account != nil { + if m.AddressIndex != nil { { - size, err := m.Account.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5846,7 +5847,7 @@ func (m *BalancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ViewAuthToken) Marshal() (dAtA []byte, err error) { +func (m *EphemeralAddressResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5856,27 +5857,32 @@ func (m *ViewAuthToken) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ViewAuthToken) MarshalTo(dAtA []byte) (int, error) { +func (m *EphemeralAddressResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ViewAuthToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *EphemeralAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Inner) > 0 { - i -= len(m.Inner) - copy(dAtA[i:], m.Inner) - i = encodeVarintView(dAtA, i, uint64(len(m.Inner))) + if m.Address != nil { + { + size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ViewAuthRequest) Marshal() (dAtA []byte, err error) { +func (m *BalancesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5886,19 +5892,31 @@ func (m *ViewAuthRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ViewAuthRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *BalancesRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ViewAuthRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *BalancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Fvk != nil { + if m.AssetIdFilter != nil { + { + size, err := m.AssetIdFilter.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.AccountFilter != nil { { - size, err := m.Fvk.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.AccountFilter.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5911,7 +5929,7 @@ func (m *ViewAuthRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ViewAuthResponse) Marshal() (dAtA []byte, err error) { +func (m *BalancesResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5921,19 +5939,31 @@ func (m *ViewAuthResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ViewAuthResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *BalancesResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ViewAuthResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *BalancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Token != nil { + if m.Balance != nil { + { + size, err := m.Balance.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Account != nil { { - size, err := m.Token.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Account.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5966,39 +5996,9 @@ func (m *StatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.XAccountGroupId != nil { - { - size := m.XAccountGroupId.Size() - i -= size - if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } return len(dAtA) - i, nil } -func (m *StatusRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatusRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 - } - return len(dAtA) - i, nil -} func (m *StatusResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -6027,10 +6027,15 @@ func (m *StatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0 } i-- + dAtA[i] = 0x18 + } + if m.PartialSyncHeight != 0 { + i = encodeVarintView(dAtA, i, uint64(m.PartialSyncHeight)) + i-- dAtA[i] = 0x10 } - if m.SyncHeight != 0 { - i = encodeVarintView(dAtA, i, uint64(m.SyncHeight)) + if m.FullSyncHeight != 0 { + i = encodeVarintView(dAtA, i, uint64(m.FullSyncHeight)) i-- dAtA[i] = 0x8 } @@ -6057,39 +6062,9 @@ func (m *StatusStreamRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.XAccountGroupId != nil { - { - size := m.XAccountGroupId.Size() - i -= size - if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } return len(dAtA) - i, nil } -func (m *StatusStreamRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatusStreamRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 - } - return len(dAtA) - i, nil -} func (m *StatusStreamResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -6110,8 +6085,13 @@ func (m *StatusStreamResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.SyncHeight != 0 { - i = encodeVarintView(dAtA, i, uint64(m.SyncHeight)) + if m.PartialSyncHeight != 0 { + i = encodeVarintView(dAtA, i, uint64(m.PartialSyncHeight)) + i-- + dAtA[i] = 0x18 + } + if m.FullSyncHeight != 0 { + i = encodeVarintView(dAtA, i, uint64(m.FullSyncHeight)) i-- dAtA[i] = 0x10 } @@ -6143,15 +6123,6 @@ func (m *NotesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.XAccountGroupId != nil { - { - size := m.XAccountGroupId.Size() - i -= size - if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } if m.AmountToSpend != nil { { size, err := m.AmountToSpend.MarshalToSizedBuffer(dAtA[:i]) @@ -6201,27 +6172,6 @@ func (m *NotesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *NotesRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotesRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 - } - return len(dAtA) - i, nil -} func (m *NotesForVotingRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -6242,15 +6192,6 @@ func (m *NotesForVotingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.XAccountGroupId != nil { - { - size := m.XAccountGroupId.Size() - i -= size - if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } if m.AddressIndex != nil { { size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i]) @@ -6271,27 +6212,6 @@ func (m *NotesForVotingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *NotesForVotingRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NotesForVotingRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 - } - return len(dAtA) - i, nil -} func (m *WitnessRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -6312,15 +6232,6 @@ func (m *WitnessRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.XAccountGroupId != nil { - { - size := m.XAccountGroupId.Size() - i -= size - if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } if m.TransactionPlan != nil { { size, err := m.TransactionPlan.MarshalToSizedBuffer(dAtA[:i]) @@ -6350,27 +6261,6 @@ func (m *WitnessRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *WitnessRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *WitnessRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 - } - return len(dAtA) - i, nil -} func (m *WitnessResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -6620,7 +6510,7 @@ func (m *AssetsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ChainParametersRequest) Marshal() (dAtA []byte, err error) { +func (m *AppParametersRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6630,12 +6520,12 @@ func (m *ChainParametersRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ChainParametersRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *AppParametersRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChainParametersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AppParametersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6643,7 +6533,7 @@ func (m *ChainParametersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *ChainParametersResponse) Marshal() (dAtA []byte, err error) { +func (m *AppParametersResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6653,12 +6543,12 @@ func (m *ChainParametersResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ChainParametersResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *AppParametersResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChainParametersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AppParametersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6678,6 +6568,64 @@ func (m *ChainParametersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } +func (m *GasPricesRequest) 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 *GasPricesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GasPricesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *GasPricesResponse) 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 *GasPricesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GasPricesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.GasPrices != nil { + { + size, err := m.GasPrices.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *FMDParametersRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -6756,15 +6704,6 @@ func (m *NoteByCommitmentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l - if m.XAccountGroupId != nil { - { - size := m.XAccountGroupId.Size() - i -= size - if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } if m.AwaitDetection { i-- if m.AwaitDetection { @@ -6790,27 +6729,6 @@ func (m *NoteByCommitmentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *NoteByCommitmentRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NoteByCommitmentRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 - } - return len(dAtA) - i, nil -} func (m *NoteByCommitmentResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -6866,15 +6784,6 @@ func (m *SwapByCommitmentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l - if m.XAccountGroupId != nil { - { - size := m.XAccountGroupId.Size() - i -= size - if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } if m.AwaitDetection { i-- if m.AwaitDetection { @@ -6900,16 +6809,29 @@ func (m *SwapByCommitmentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *SwapByCommitmentRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) { +func (m *SwapByCommitmentResponse) 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 *SwapByCommitmentResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SwapByCommitmentRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *SwapByCommitmentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.AccountGroupId != nil { + _ = i + var l int + _ = l + if m.Swap != nil { { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -6917,11 +6839,12 @@ func (m *SwapByCommitmentRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byt i = encodeVarintView(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x72 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SwapByCommitmentResponse) Marshal() (dAtA []byte, err error) { + +func (m *UnclaimedSwapsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6931,12 +6854,35 @@ func (m *SwapByCommitmentResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SwapByCommitmentResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *UnclaimedSwapsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SwapByCommitmentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *UnclaimedSwapsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *UnclaimedSwapsResponse) 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 *UnclaimedSwapsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UnclaimedSwapsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6976,15 +6922,6 @@ func (m *NullifierStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l - if m.XAccountGroupId != nil { - { - size := m.XAccountGroupId.Size() - i -= size - if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } if m.AwaitDetection { i-- if m.AwaitDetection { @@ -7010,27 +6947,6 @@ func (m *NullifierStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *NullifierStatusRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NullifierStatusRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.AccountGroupId != nil { - { - size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 - } - return len(dAtA) - i, nil -} func (m *NullifierStatusResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7119,51 +7035,19 @@ func (m *TransactionInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l - if m.XEndHeight != nil { - { - size := m.XEndHeight.Size() - i -= size - if _, err := m.XEndHeight.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } + if m.EndHeight != 0 { + i = encodeVarintView(dAtA, i, uint64(m.EndHeight)) + i-- + dAtA[i] = 0x10 } - if m.XStartHeight != nil { - { - size := m.XStartHeight.Size() - i -= size - if _, err := m.XStartHeight.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } + if m.StartHeight != 0 { + i = encodeVarintView(dAtA, i, uint64(m.StartHeight)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *TransactionInfoRequest_StartHeight) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TransactionInfoRequest_StartHeight) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintView(dAtA, i, uint64(m.StartHeight)) - i-- - dAtA[i] = 0x8 - return len(dAtA) - i, nil -} -func (m *TransactionInfoRequest_EndHeight) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TransactionInfoRequest_EndHeight) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintView(dAtA, i, uint64(m.EndHeight)) - i-- - dAtA[i] = 0x10 - return len(dAtA) - i, nil -} func (m *TransactionInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7232,30 +7116,14 @@ func (m *TransactionInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if m.XHeight != nil { - { - size := m.XHeight.Size() - i -= size - if _, err := m.XHeight.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } + if m.Height != 0 { + i = encodeVarintView(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *TransactionInfo_Height) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TransactionInfo_Height) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintView(dAtA, i, uint64(m.Height)) - i-- - dAtA[i] = 0x8 - return len(dAtA) - i, nil -} func (m *TransactionInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7445,14 +7313,10 @@ func (m *SpendableNoteRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x38 } - if m.XHeightSpent != nil { - { - size := m.XHeightSpent.Size() - i -= size - if _, err := m.XHeightSpent.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } + if m.HeightSpent != 0 { + i = encodeVarintView(dAtA, i, uint64(m.HeightSpent)) + i-- + dAtA[i] = 0x30 } if m.HeightCreated != 0 { i = encodeVarintView(dAtA, i, uint64(m.HeightCreated)) @@ -7510,18 +7374,6 @@ func (m *SpendableNoteRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SpendableNoteRecord_HeightSpent) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SpendableNoteRecord_HeightSpent) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintView(dAtA, i, uint64(m.HeightSpent)) - i-- - dAtA[i] = 0x30 - return len(dAtA) - i, nil -} func (m *SwapRecord) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7554,14 +7406,10 @@ func (m *SwapRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x3a } - if m.XHeightClaimed != nil { - { - size := m.XHeightClaimed.Size() - i -= size - if _, err := m.XHeightClaimed.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } + if m.HeightClaimed != 0 { + i = encodeVarintView(dAtA, i, uint64(m.HeightClaimed)) + i-- + dAtA[i] = 0x30 } if m.OutputData != nil { { @@ -7619,18 +7467,6 @@ func (m *SwapRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SwapRecord_HeightClaimed) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapRecord_HeightClaimed) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintView(dAtA, i, uint64(m.HeightClaimed)) - i-- - dAtA[i] = 0x30 - return len(dAtA) - i, nil -} func (m *OwnedPositionIdsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7651,34 +7487,18 @@ func (m *OwnedPositionIdsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l - if m.XTradingPair != nil { + if m.TradingPair != nil { { - size := m.XTradingPair.Size() - i -= size - if _, err := m.XTradingPair.MarshalTo(dAtA[i:]); err != nil { + size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { return 0, err } - } - } - if m.XPositionState != nil { - { - size := m.XPositionState.Size() i -= size - if _, err := m.XPositionState.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } + i = encodeVarintView(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x12 } - return len(dAtA) - i, nil -} - -func (m *OwnedPositionIdsRequest_PositionState) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *OwnedPositionIdsRequest_PositionState) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) if m.PositionState != nil { { size, err := m.PositionState.MarshalToSizedBuffer(dAtA[:i]) @@ -7693,27 +7513,7 @@ func (m *OwnedPositionIdsRequest_PositionState) MarshalToSizedBuffer(dAtA []byte } return len(dAtA) - i, nil } -func (m *OwnedPositionIdsRequest_TradingPair) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} -func (m *OwnedPositionIdsRequest_TradingPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.TradingPair != nil { - { - size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintView(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} func (m *OwnedPositionIdsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7839,8 +7639,9 @@ func (m *TransactionPlannerRequest) Size() (n int) { l = m.Memo.Size() n += 1 + l + sovView(uint64(l)) } - if m.XAccountGroupId != nil { - n += m.XAccountGroupId.Size() + if m.Source != nil { + l = m.Source.Size() + n += 1 + l + sovView(uint64(l)) } if len(m.Outputs) > 0 { for _, e := range m.Outputs { @@ -7872,27 +7673,39 @@ func (m *TransactionPlannerRequest) Size() (n int) { n += 2 + l + sovView(uint64(l)) } } - if len(m.IbcActions) > 0 { - for _, e := range m.IbcActions { + if len(m.IbcRelayActions) > 0 { + for _, e := range m.IbcRelayActions { l = e.Size() n += 2 + l + sovView(uint64(l)) } } - return n -} - -func (m *TransactionPlannerRequest_AccountGroupId) Size() (n int) { - if m == nil { - return 0 + if len(m.Ics20Withdrawals) > 0 { + for _, e := range m.Ics20Withdrawals { + l = e.Size() + n += 2 + l + sovView(uint64(l)) + } } - var l int - _ = l - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() - n += 1 + l + sovView(uint64(l)) + if len(m.PositionOpens) > 0 { + for _, e := range m.PositionOpens { + l = e.Size() + n += 2 + l + sovView(uint64(l)) + } + } + if len(m.PositionCloses) > 0 { + for _, e := range m.PositionCloses { + l = e.Size() + n += 2 + l + sovView(uint64(l)) + } + } + if len(m.PositionWithdraws) > 0 { + for _, e := range m.PositionWithdraws { + l = e.Size() + n += 2 + l + sovView(uint64(l)) + } } return n } + func (m *TransactionPlannerRequest_Output) Size() (n int) { if m == nil { return 0 @@ -7928,6 +7741,10 @@ func (m *TransactionPlannerRequest_Swap) Size() (n int) { l = m.Fee.Size() n += 1 + l + sovView(uint64(l)) } + if m.ClaimAddress != nil { + l = m.ClaimAddress.Size() + n += 1 + l + sovView(uint64(l)) + } return n } @@ -7978,219 +7795,223 @@ func (m *TransactionPlannerRequest_Undelegate) Size() (n int) { return n } -func (m *TransactionPlannerResponse) Size() (n int) { +func (m *TransactionPlannerRequest_PositionOpen) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Plan != nil { - l = m.Plan.Size() + if m.Position != nil { + l = m.Position.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *AddressByIndexRequest) Size() (n int) { +func (m *TransactionPlannerRequest_PositionClose) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.AddressIndex != nil { - l = m.AddressIndex.Size() + if m.PositionId != nil { + l = m.PositionId.Size() n += 1 + l + sovView(uint64(l)) } - if m.DisplayConfirm { - n += 2 - } return n } -func (m *AddressByIndexResponse) Size() (n int) { +func (m *TransactionPlannerRequest_PositionWithdraw) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Address != nil { - l = m.Address.Size() + if m.PositionId != nil { + l = m.PositionId.Size() + n += 1 + l + sovView(uint64(l)) + } + if m.Reserves != nil { + l = m.Reserves.Size() + n += 1 + l + sovView(uint64(l)) + } + if m.TradingPair != nil { + l = m.TradingPair.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *IndexByAddressRequest) Size() (n int) { +func (m *TransactionPlannerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Address != nil { - l = m.Address.Size() + if m.Plan != nil { + l = m.Plan.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *IndexByAddressResponse) Size() (n int) { +func (m *AddressByIndexRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.XAddressIndex != nil { - n += m.XAddressIndex.Size() + if m.AddressIndex != nil { + l = m.AddressIndex.Size() + n += 1 + l + sovView(uint64(l)) } return n } -func (m *IndexByAddressResponse_AddressIndex) Size() (n int) { +func (m *AddressByIndexResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.AddressIndex != nil { - l = m.AddressIndex.Size() + if m.Address != nil { + l = m.Address.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *EphemeralAddressRequest) Size() (n int) { + +func (m *WalletIdRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.AddressIndex != nil { - l = m.AddressIndex.Size() - n += 1 + l + sovView(uint64(l)) - } - if m.DisplayConfirm { - n += 2 - } return n } -func (m *EphemeralAddressResponse) Size() (n int) { +func (m *WalletIdResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Address != nil { - l = m.Address.Size() + if m.WalletId != nil { + l = m.WalletId.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *BalancesRequest) Size() (n int) { +func (m *IndexByAddressRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.AccountFilter != nil { - l = m.AccountFilter.Size() - n += 1 + l + sovView(uint64(l)) - } - if m.AssetIdFilter != nil { - l = m.AssetIdFilter.Size() + if m.Address != nil { + l = m.Address.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *BalancesResponse) Size() (n int) { +func (m *IndexByAddressResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Account != nil { - l = m.Account.Size() - n += 1 + l + sovView(uint64(l)) - } - if m.Balance != nil { - l = m.Balance.Size() + if m.AddressIndex != nil { + l = m.AddressIndex.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *ViewAuthToken) Size() (n int) { +func (m *EphemeralAddressRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Inner) - if l > 0 { + if m.AddressIndex != nil { + l = m.AddressIndex.Size() n += 1 + l + sovView(uint64(l)) } + if m.DisplayConfirm { + n += 2 + } return n } -func (m *ViewAuthRequest) Size() (n int) { +func (m *EphemeralAddressResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Fvk != nil { - l = m.Fvk.Size() + if m.Address != nil { + l = m.Address.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *ViewAuthResponse) Size() (n int) { +func (m *BalancesRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Token != nil { - l = m.Token.Size() + if m.AccountFilter != nil { + l = m.AccountFilter.Size() + n += 1 + l + sovView(uint64(l)) + } + if m.AssetIdFilter != nil { + l = m.AssetIdFilter.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *StatusRequest) Size() (n int) { +func (m *BalancesResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.XAccountGroupId != nil { - n += m.XAccountGroupId.Size() + if m.Account != nil { + l = m.Account.Size() + n += 1 + l + sovView(uint64(l)) + } + if m.Balance != nil { + l = m.Balance.Size() + n += 1 + l + sovView(uint64(l)) } return n } -func (m *StatusRequest_AccountGroupId) Size() (n int) { +func (m *StatusRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() - n += 1 + l + sovView(uint64(l)) - } return n } + func (m *StatusResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.SyncHeight != 0 { - n += 1 + sovView(uint64(m.SyncHeight)) + if m.FullSyncHeight != 0 { + n += 1 + sovView(uint64(m.FullSyncHeight)) + } + if m.PartialSyncHeight != 0 { + n += 1 + sovView(uint64(m.PartialSyncHeight)) } if m.CatchingUp { n += 2 @@ -8204,24 +8025,9 @@ func (m *StatusStreamRequest) Size() (n int) { } var l int _ = l - if m.XAccountGroupId != nil { - n += m.XAccountGroupId.Size() - } return n } -func (m *StatusStreamRequest_AccountGroupId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() - n += 1 + l + sovView(uint64(l)) - } - return n -} func (m *StatusStreamResponse) Size() (n int) { if m == nil { return 0 @@ -8231,8 +8037,11 @@ func (m *StatusStreamResponse) Size() (n int) { if m.LatestKnownBlockHeight != 0 { n += 1 + sovView(uint64(m.LatestKnownBlockHeight)) } - if m.SyncHeight != 0 { - n += 1 + sovView(uint64(m.SyncHeight)) + if m.FullSyncHeight != 0 { + n += 1 + sovView(uint64(m.FullSyncHeight)) + } + if m.PartialSyncHeight != 0 { + n += 1 + sovView(uint64(m.PartialSyncHeight)) } return n } @@ -8258,24 +8067,9 @@ func (m *NotesRequest) Size() (n int) { l = m.AmountToSpend.Size() n += 1 + l + sovView(uint64(l)) } - if m.XAccountGroupId != nil { - n += m.XAccountGroupId.Size() - } return n } -func (m *NotesRequest_AccountGroupId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() - n += 1 + l + sovView(uint64(l)) - } - return n -} func (m *NotesForVotingRequest) Size() (n int) { if m == nil { return 0 @@ -8289,24 +8083,9 @@ func (m *NotesForVotingRequest) Size() (n int) { l = m.AddressIndex.Size() n += 1 + l + sovView(uint64(l)) } - if m.XAccountGroupId != nil { - n += m.XAccountGroupId.Size() - } return n } -func (m *NotesForVotingRequest_AccountGroupId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() - n += 1 + l + sovView(uint64(l)) - } - return n -} func (m *WitnessRequest) Size() (n int) { if m == nil { return 0 @@ -8323,24 +8102,9 @@ func (m *WitnessRequest) Size() (n int) { l = m.TransactionPlan.Size() n += 1 + l + sovView(uint64(l)) } - if m.XAccountGroupId != nil { - n += m.XAccountGroupId.Size() - } return n } -func (m *WitnessRequest_AccountGroupId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() - n += 1 + l + sovView(uint64(l)) - } - return n -} func (m *WitnessResponse) Size() (n int) { if m == nil { return 0 @@ -8430,7 +8194,7 @@ func (m *AssetsResponse) Size() (n int) { return n } -func (m *ChainParametersRequest) Size() (n int) { +func (m *AppParametersRequest) Size() (n int) { if m == nil { return 0 } @@ -8439,7 +8203,7 @@ func (m *ChainParametersRequest) Size() (n int) { return n } -func (m *ChainParametersResponse) Size() (n int) { +func (m *AppParametersResponse) Size() (n int) { if m == nil { return 0 } @@ -8452,7 +8216,7 @@ func (m *ChainParametersResponse) Size() (n int) { return n } -func (m *FMDParametersRequest) Size() (n int) { +func (m *GasPricesRequest) Size() (n int) { if m == nil { return 0 } @@ -8461,50 +8225,57 @@ func (m *FMDParametersRequest) Size() (n int) { return n } -func (m *FMDParametersResponse) Size() (n int) { +func (m *GasPricesResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Parameters != nil { - l = m.Parameters.Size() + if m.GasPrices != nil { + l = m.GasPrices.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *NoteByCommitmentRequest) Size() (n int) { +func (m *FMDParametersRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.NoteCommitment != nil { - l = m.NoteCommitment.Size() - n += 1 + l + sovView(uint64(l)) - } - if m.AwaitDetection { - n += 2 + return n +} + +func (m *FMDParametersResponse) Size() (n int) { + if m == nil { + return 0 } - if m.XAccountGroupId != nil { - n += m.XAccountGroupId.Size() + var l int + _ = l + if m.Parameters != nil { + l = m.Parameters.Size() + n += 1 + l + sovView(uint64(l)) } return n } -func (m *NoteByCommitmentRequest_AccountGroupId) Size() (n int) { +func (m *NoteByCommitmentRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() + if m.NoteCommitment != nil { + l = m.NoteCommitment.Size() n += 1 + l + sovView(uint64(l)) } + if m.AwaitDetection { + n += 2 + } return n } + func (m *NoteByCommitmentResponse) Size() (n int) { if m == nil { return 0 @@ -8531,25 +8302,32 @@ func (m *SwapByCommitmentRequest) Size() (n int) { if m.AwaitDetection { n += 2 } - if m.XAccountGroupId != nil { - n += m.XAccountGroupId.Size() - } return n } -func (m *SwapByCommitmentRequest_AccountGroupId) Size() (n int) { +func (m *SwapByCommitmentResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() + if m.Swap != nil { + l = m.Swap.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *SwapByCommitmentResponse) Size() (n int) { + +func (m *UnclaimedSwapsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *UnclaimedSwapsResponse) Size() (n int) { if m == nil { return 0 } @@ -8575,24 +8353,9 @@ func (m *NullifierStatusRequest) Size() (n int) { if m.AwaitDetection { n += 2 } - if m.XAccountGroupId != nil { - n += m.XAccountGroupId.Size() - } return n } -func (m *NullifierStatusRequest_AccountGroupId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AccountGroupId != nil { - l = m.AccountGroupId.Size() - n += 1 + l + sovView(uint64(l)) - } - return n -} func (m *NullifierStatusResponse) Size() (n int) { if m == nil { return 0 @@ -8624,41 +8387,23 @@ func (m *TransactionInfoRequest) Size() (n int) { } var l int _ = l - if m.XStartHeight != nil { - n += m.XStartHeight.Size() + if m.StartHeight != 0 { + n += 1 + sovView(uint64(m.StartHeight)) } - if m.XEndHeight != nil { - n += m.XEndHeight.Size() + if m.EndHeight != 0 { + n += 1 + sovView(uint64(m.EndHeight)) } return n } -func (m *TransactionInfoRequest_StartHeight) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - n += 1 + sovView(uint64(m.StartHeight)) - return n -} -func (m *TransactionInfoRequest_EndHeight) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - n += 1 + sovView(uint64(m.EndHeight)) - return n -} func (m *TransactionInfo) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.XHeight != nil { - n += m.XHeight.Size() + if m.Height != 0 { + n += 1 + sovView(uint64(m.Height)) } if m.Id != nil { l = m.Id.Size() @@ -8679,15 +8424,6 @@ func (m *TransactionInfo) Size() (n int) { return n } -func (m *TransactionInfo_Height) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - n += 1 + sovView(uint64(m.Height)) - return n -} func (m *TransactionInfoResponse) Size() (n int) { if m == nil { return 0 @@ -8769,8 +8505,8 @@ func (m *SpendableNoteRecord) Size() (n int) { if m.HeightCreated != 0 { n += 1 + sovView(uint64(m.HeightCreated)) } - if m.XHeightSpent != nil { - n += m.XHeightSpent.Size() + if m.HeightSpent != 0 { + n += 1 + sovView(uint64(m.HeightSpent)) } if m.Position != 0 { n += 1 + sovView(uint64(m.Position)) @@ -8782,15 +8518,6 @@ func (m *SpendableNoteRecord) Size() (n int) { return n } -func (m *SpendableNoteRecord_HeightSpent) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - n += 1 + sovView(uint64(m.HeightSpent)) - return n -} func (m *SwapRecord) Size() (n int) { if m == nil { return 0 @@ -8816,8 +8543,8 @@ func (m *SwapRecord) Size() (n int) { l = m.OutputData.Size() n += 1 + l + sovView(uint64(l)) } - if m.XHeightClaimed != nil { - n += m.XHeightClaimed.Size() + if m.HeightClaimed != 0 { + n += 1 + sovView(uint64(m.HeightClaimed)) } if m.Source != nil { l = m.Source.Size() @@ -8826,31 +8553,7 @@ func (m *SwapRecord) Size() (n int) { return n } -func (m *SwapRecord_HeightClaimed) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - n += 1 + sovView(uint64(m.HeightClaimed)) - return n -} func (m *OwnedPositionIdsRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XPositionState != nil { - n += m.XPositionState.Size() - } - if m.XTradingPair != nil { - n += m.XTradingPair.Size() - } - return n -} - -func (m *OwnedPositionIdsRequest_PositionState) Size() (n int) { if m == nil { return 0 } @@ -8860,20 +8563,13 @@ func (m *OwnedPositionIdsRequest_PositionState) Size() (n int) { l = m.PositionState.Size() n += 1 + l + sovView(uint64(l)) } - return n -} -func (m *OwnedPositionIdsRequest_TradingPair) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l if m.TradingPair != nil { l = m.TradingPair.Size() n += 1 + l + sovView(uint64(l)) } return n } + func (m *OwnedPositionIdsResponse) Size() (n int) { if m == nil { return 0 @@ -9266,7 +8962,7 @@ func (m *BroadcastTransactionResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Id == nil { - m.Id = &v1alpha1.Id{} + m.Id = &v1alpha11.TransactionId{} } if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -9390,7 +9086,7 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Fee == nil { - m.Fee = &v1alpha11.Fee{} + m.Fee = &v1alpha12.Fee{} } if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -9432,9 +9128,9 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 14: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -9461,11 +9157,12 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.AccountGroupId{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Source == nil { + m.Source = &v1alpha13.AddressIndex{} + } + if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.XAccountGroupId = &TransactionPlannerRequest_AccountGroupId{v} iNdEx = postIndex case 20: if wireType != 2 { @@ -9629,17 +9326,553 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error { if postIndex < 0 { return ErrInvalidLengthView } - if postIndex > l { + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Undelegations = append(m.Undelegations, &TransactionPlannerRequest_Undelegate{}) + if err := m.Undelegations[len(m.Undelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 60: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IbcRelayActions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IbcRelayActions = append(m.IbcRelayActions, &v1alpha14.IbcRelay{}) + if err := m.IbcRelayActions[len(m.IbcRelayActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 61: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ics20Withdrawals", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ics20Withdrawals = append(m.Ics20Withdrawals, &v1alpha14.Ics20Withdrawal{}) + if err := m.Ics20Withdrawals[len(m.Ics20Withdrawals)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 70: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionOpens", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PositionOpens = append(m.PositionOpens, &TransactionPlannerRequest_PositionOpen{}) + if err := m.PositionOpens[len(m.PositionOpens)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 71: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionCloses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PositionCloses = append(m.PositionCloses, &TransactionPlannerRequest_PositionClose{}) + if err := m.PositionCloses[len(m.PositionCloses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 72: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionWithdraws", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PositionWithdraws = append(m.PositionWithdraws, &TransactionPlannerRequest_PositionWithdraw{}) + if err := m.PositionWithdraws[len(m.PositionWithdraws)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipView(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthView + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TransactionPlannerRequest_Output) 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 ErrIntOverflowView + } + 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: Output: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Output: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &v1alpha15.Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &v1alpha13.Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipView(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthView + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TransactionPlannerRequest_Swap) 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 ErrIntOverflowView + } + 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: Swap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Swap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &v1alpha15.Value{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TargetAsset", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TargetAsset == nil { + m.TargetAsset = &v1alpha15.AssetId{} + } + if err := m.TargetAsset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Fee == nil { + m.Fee = &v1alpha12.Fee{} + } + if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClaimAddress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ClaimAddress == nil { + m.ClaimAddress = &v1alpha13.Address{} + } + if err := m.ClaimAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipView(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthView + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TransactionPlannerRequest_SwapClaim) 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 ErrIntOverflowView + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.Undelegations = append(m.Undelegations, &TransactionPlannerRequest_Undelegate{}) - if err := m.Undelegations[len(m.Undelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 60: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SwapClaim: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapClaim: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IbcActions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SwapCommitment", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -9666,8 +9899,10 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.IbcActions = append(m.IbcActions, &v1alpha12.IbcAction{}) - if err := m.IbcActions[len(m.IbcActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.SwapCommitment == nil { + m.SwapCommitment = &v1alpha16.StateCommitment{} + } + if err := m.SwapCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -9692,7 +9927,7 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransactionPlannerRequest_Output) Unmarshal(dAtA []byte) error { +func (m *TransactionPlannerRequest_Delegate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9715,15 +9950,15 @@ func (m *TransactionPlannerRequest_Output) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Output: wiretype end group for non-group") + return fmt.Errorf("proto: Delegate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Output: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Delegate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -9750,16 +9985,16 @@ func (m *TransactionPlannerRequest_Output) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Value == nil { - m.Value = &v1alpha11.Value{} + if m.Amount == nil { + m.Amount = &v1alpha17.Amount{} } - if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -9786,10 +10021,10 @@ func (m *TransactionPlannerRequest_Output) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Address == nil { - m.Address = &v1alpha11.Address{} + if m.RateData == nil { + m.RateData = &v1alpha18.RateData{} } - if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -9814,7 +10049,7 @@ func (m *TransactionPlannerRequest_Output) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error { +func (m *TransactionPlannerRequest_Undelegate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9837,10 +10072,10 @@ func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Swap: wiretype end group for non-group") + return fmt.Errorf("proto: Undelegate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Swap: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Undelegate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -9873,7 +10108,7 @@ func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Value == nil { - m.Value = &v1alpha11.Value{} + m.Value = &v1alpha15.Value{} } if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -9881,43 +10116,7 @@ func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TargetAsset", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.TargetAsset == nil { - m.TargetAsset = &v1alpha11.AssetId{} - } - if err := m.TargetAsset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -9944,10 +10143,10 @@ func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Fee == nil { - m.Fee = &v1alpha11.Fee{} + if m.RateData == nil { + m.RateData = &v1alpha18.RateData{} } - if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -9972,7 +10171,7 @@ func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransactionPlannerRequest_SwapClaim) Unmarshal(dAtA []byte) error { +func (m *TransactionPlannerRequest_PositionOpen) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9995,15 +10194,15 @@ func (m *TransactionPlannerRequest_SwapClaim) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SwapClaim: wiretype end group for non-group") + return fmt.Errorf("proto: PositionOpen: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SwapClaim: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PositionOpen: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwapCommitment", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10030,10 +10229,10 @@ func (m *TransactionPlannerRequest_SwapClaim) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.SwapCommitment == nil { - m.SwapCommitment = &v1alpha11.StateCommitment{} + if m.Position == nil { + m.Position = &v1alpha19.Position{} } - if err := m.SwapCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Position.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -10058,7 +10257,7 @@ func (m *TransactionPlannerRequest_SwapClaim) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransactionPlannerRequest_Delegate) Unmarshal(dAtA []byte) error { +func (m *TransactionPlannerRequest_PositionClose) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10081,51 +10280,15 @@ func (m *TransactionPlannerRequest_Delegate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Delegate: wiretype end group for non-group") + return fmt.Errorf("proto: PositionClose: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Delegate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PositionClose: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Amount == nil { - m.Amount = &v1alpha11.Amount{} - } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10152,10 +10315,10 @@ func (m *TransactionPlannerRequest_Delegate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.RateData == nil { - m.RateData = &v1alpha13.RateData{} + if m.PositionId == nil { + m.PositionId = &v1alpha19.PositionId{} } - if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -10180,7 +10343,7 @@ func (m *TransactionPlannerRequest_Delegate) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransactionPlannerRequest_Undelegate) Unmarshal(dAtA []byte) error { +func (m *TransactionPlannerRequest_PositionWithdraw) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10203,15 +10366,15 @@ func (m *TransactionPlannerRequest_Undelegate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Undelegate: wiretype end group for non-group") + return fmt.Errorf("proto: PositionWithdraw: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Undelegate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PositionWithdraw: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10238,16 +10401,16 @@ func (m *TransactionPlannerRequest_Undelegate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Value == nil { - m.Value = &v1alpha11.Value{} + if m.PositionId == nil { + m.PositionId = &v1alpha19.PositionId{} } - if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Reserves", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10274,66 +10437,16 @@ func (m *TransactionPlannerRequest_Undelegate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.RateData == nil { - m.RateData = &v1alpha13.RateData{} + if m.Reserves == nil { + m.Reserves = &v1alpha19.Reserves{} } - if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Reserves.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipView(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthView - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TransactionPlannerResponse) 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 ErrIntOverflowView - } - 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: TransactionPlannerResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TransactionPlannerResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10360,10 +10473,10 @@ func (m *TransactionPlannerResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Plan == nil { - m.Plan = &v1alpha1.TransactionPlan{} + if m.TradingPair == nil { + m.TradingPair = &v1alpha19.TradingPair{} } - if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -10388,7 +10501,7 @@ func (m *TransactionPlannerResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *AddressByIndexRequest) Unmarshal(dAtA []byte) error { +func (m *TransactionPlannerResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10411,15 +10524,15 @@ func (m *AddressByIndexRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AddressByIndexRequest: wiretype end group for non-group") + return fmt.Errorf("proto: TransactionPlannerResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AddressByIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TransactionPlannerResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10446,33 +10559,13 @@ func (m *AddressByIndexRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.AddressIndex == nil { - m.AddressIndex = &v1alpha11.AddressIndex{} - } - if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DisplayConfirm", wireType) + if m.Plan == nil { + m.Plan = &v1alpha1.TransactionPlan{} } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } + if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.DisplayConfirm = bool(v != 0) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -10494,7 +10587,7 @@ func (m *AddressByIndexRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *AddressByIndexResponse) Unmarshal(dAtA []byte) error { +func (m *AddressByIndexRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10517,15 +10610,15 @@ func (m *AddressByIndexResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AddressByIndexResponse: wiretype end group for non-group") + return fmt.Errorf("proto: AddressByIndexRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AddressByIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AddressByIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10552,10 +10645,10 @@ func (m *AddressByIndexResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Address == nil { - m.Address = &v1alpha11.Address{} + if m.AddressIndex == nil { + m.AddressIndex = &v1alpha13.AddressIndex{} } - if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -10580,7 +10673,7 @@ func (m *AddressByIndexResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *IndexByAddressRequest) Unmarshal(dAtA []byte) error { +func (m *AddressByIndexResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10603,10 +10696,10 @@ func (m *IndexByAddressRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: IndexByAddressRequest: wiretype end group for non-group") + return fmt.Errorf("proto: AddressByIndexResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: IndexByAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AddressByIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10639,7 +10732,7 @@ func (m *IndexByAddressRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Address == nil { - m.Address = &v1alpha11.Address{} + m.Address = &v1alpha13.Address{} } if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -10666,7 +10759,7 @@ func (m *IndexByAddressRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *IndexByAddressResponse) Unmarshal(dAtA []byte) error { +func (m *WalletIdRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10689,47 +10782,12 @@ func (m *IndexByAddressResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: IndexByAddressResponse: wiretype end group for non-group") + return fmt.Errorf("proto: WalletIdRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: IndexByAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: WalletIdRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.AddressIndex{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.XAddressIndex = &IndexByAddressResponse_AddressIndex{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -10751,7 +10809,7 @@ func (m *IndexByAddressResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error { +func (m *WalletIdResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10774,15 +10832,15 @@ func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EphemeralAddressRequest: wiretype end group for non-group") + return fmt.Errorf("proto: WalletIdResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EphemeralAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: WalletIdResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WalletId", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10809,33 +10867,13 @@ func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.AddressIndex == nil { - m.AddressIndex = &v1alpha11.AddressIndex{} + if m.WalletId == nil { + m.WalletId = &v1alpha13.WalletId{} } - if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.WalletId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DisplayConfirm", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.DisplayConfirm = bool(v != 0) default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -10857,7 +10895,7 @@ func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *EphemeralAddressResponse) Unmarshal(dAtA []byte) error { +func (m *IndexByAddressRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10880,10 +10918,10 @@ func (m *EphemeralAddressResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EphemeralAddressResponse: wiretype end group for non-group") + return fmt.Errorf("proto: IndexByAddressRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EphemeralAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IndexByAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10916,7 +10954,7 @@ func (m *EphemeralAddressResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Address == nil { - m.Address = &v1alpha11.Address{} + m.Address = &v1alpha13.Address{} } if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -10943,7 +10981,7 @@ func (m *EphemeralAddressResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *BalancesRequest) Unmarshal(dAtA []byte) error { +func (m *IndexByAddressResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10966,51 +11004,15 @@ func (m *BalancesRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BalancesRequest: wiretype end group for non-group") + return fmt.Errorf("proto: IndexByAddressResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IndexByAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountFilter", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.AccountFilter == nil { - m.AccountFilter = &v1alpha11.AddressIndex{} - } - if err := m.AccountFilter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AssetIdFilter", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11037,10 +11039,10 @@ func (m *BalancesRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.AssetIdFilter == nil { - m.AssetIdFilter = &v1alpha11.AssetId{} + if m.AddressIndex == nil { + m.AddressIndex = &v1alpha13.AddressIndex{} } - if err := m.AssetIdFilter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -11065,7 +11067,7 @@ func (m *BalancesRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *BalancesResponse) Unmarshal(dAtA []byte) error { +func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11088,15 +11090,15 @@ func (m *BalancesResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BalancesResponse: wiretype end group for non-group") + return fmt.Errorf("proto: EphemeralAddressRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EphemeralAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11123,18 +11125,18 @@ func (m *BalancesResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Account == nil { - m.Account = &v1alpha11.AddressIndex{} + if m.AddressIndex == nil { + m.AddressIndex = &v1alpha13.AddressIndex{} } - if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DisplayConfirm", wireType) } - var msglen int + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -11144,28 +11146,12 @@ func (m *BalancesResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Balance == nil { - m.Balance = &v1alpha11.Value{} - } - if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex + m.DisplayConfirm = bool(v != 0) default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -11187,7 +11173,7 @@ func (m *BalancesResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ViewAuthToken) Unmarshal(dAtA []byte) error { +func (m *EphemeralAddressResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11210,17 +11196,17 @@ func (m *ViewAuthToken) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ViewAuthToken: wiretype end group for non-group") + return fmt.Errorf("proto: EphemeralAddressResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ViewAuthToken: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EphemeralAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -11230,24 +11216,26 @@ func (m *ViewAuthToken) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthView } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthView } if postIndex > l { return io.ErrUnexpectedEOF } - m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...) - if m.Inner == nil { - m.Inner = []byte{} + if m.Address == nil { + m.Address = &v1alpha13.Address{} + } + if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -11271,7 +11259,7 @@ func (m *ViewAuthToken) Unmarshal(dAtA []byte) error { } return nil } -func (m *ViewAuthRequest) Unmarshal(dAtA []byte) error { +func (m *BalancesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11294,15 +11282,51 @@ func (m *ViewAuthRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ViewAuthRequest: wiretype end group for non-group") + return fmt.Errorf("proto: BalancesRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ViewAuthRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Fvk", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AccountFilter", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AccountFilter == nil { + m.AccountFilter = &v1alpha13.AddressIndex{} + } + if err := m.AccountFilter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetIdFilter", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11329,10 +11353,10 @@ func (m *ViewAuthRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Fvk == nil { - m.Fvk = &v1alpha11.FullViewingKey{} + if m.AssetIdFilter == nil { + m.AssetIdFilter = &v1alpha15.AssetId{} } - if err := m.Fvk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.AssetIdFilter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -11357,7 +11381,7 @@ func (m *ViewAuthRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ViewAuthResponse) Unmarshal(dAtA []byte) error { +func (m *BalancesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11380,15 +11404,51 @@ func (m *ViewAuthResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ViewAuthResponse: wiretype end group for non-group") + return fmt.Errorf("proto: BalancesResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ViewAuthResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Account == nil { + m.Account = &v1alpha13.AddressIndex{} + } + if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11415,10 +11475,10 @@ func (m *ViewAuthResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Token == nil { - m.Token = &ViewAuthToken{} + if m.Balance == nil { + m.Balance = &v1alpha15.Value{} } - if err := m.Token.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -11472,41 +11532,6 @@ func (m *StatusRequest) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: StatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.AccountGroupId{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.XAccountGroupId = &StatusRequest_AccountGroupId{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -11559,9 +11584,9 @@ func (m *StatusResponse) Unmarshal(dAtA []byte) error { switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SyncHeight", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field FullSyncHeight", wireType) } - m.SyncHeight = 0 + m.FullSyncHeight = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -11571,12 +11596,31 @@ func (m *StatusResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SyncHeight |= uint64(b&0x7F) << shift + m.FullSyncHeight |= uint64(b&0x7F) << shift if b < 0x80 { break } } case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PartialSyncHeight", wireType) + } + m.PartialSyncHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PartialSyncHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CatchingUp", wireType) } @@ -11646,41 +11690,6 @@ func (m *StatusStreamRequest) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: StatusStreamRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.AccountGroupId{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.XAccountGroupId = &StatusStreamRequest_AccountGroupId{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -11752,9 +11761,28 @@ func (m *StatusStreamResponse) Unmarshal(dAtA []byte) error { } case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SyncHeight", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field FullSyncHeight", wireType) + } + m.FullSyncHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FullSyncHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PartialSyncHeight", wireType) } - m.SyncHeight = 0 + m.PartialSyncHeight = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -11764,7 +11792,7 @@ func (m *StatusStreamResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SyncHeight |= uint64(b&0x7F) << shift + m.PartialSyncHeight |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11869,7 +11897,7 @@ func (m *NotesRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.AssetId == nil { - m.AssetId = &v1alpha11.AssetId{} + m.AssetId = &v1alpha15.AssetId{} } if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -11905,7 +11933,7 @@ func (m *NotesRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.AddressIndex == nil { - m.AddressIndex = &v1alpha11.AddressIndex{} + m.AddressIndex = &v1alpha13.AddressIndex{} } if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -11941,47 +11969,12 @@ func (m *NotesRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.AmountToSpend == nil { - m.AmountToSpend = &v1alpha11.Amount{} + m.AmountToSpend = &v1alpha17.Amount{} } if err := m.AmountToSpend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.AccountGroupId{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.XAccountGroupId = &NotesRequest_AccountGroupId{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -12081,47 +12074,12 @@ func (m *NotesForVotingRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.AddressIndex == nil { - m.AddressIndex = &v1alpha11.AddressIndex{} + m.AddressIndex = &v1alpha13.AddressIndex{} } if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.AccountGroupId{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.XAccountGroupId = &NotesForVotingRequest_AccountGroupId{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -12201,7 +12159,7 @@ func (m *WitnessRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.NoteCommitments = append(m.NoteCommitments, &v1alpha11.StateCommitment{}) + m.NoteCommitments = append(m.NoteCommitments, &v1alpha16.StateCommitment{}) if err := m.NoteCommitments[len(m.NoteCommitments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } @@ -12242,41 +12200,6 @@ func (m *WitnessRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.AccountGroupId{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.XAccountGroupId = &WitnessRequest_AccountGroupId{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -12670,7 +12593,7 @@ func (m *AssetsRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.IncludeSpecificDenominations = append(m.IncludeSpecificDenominations, &v1alpha11.Denom{}) + m.IncludeSpecificDenominations = append(m.IncludeSpecificDenominations, &v1alpha15.Denom{}) if err := m.IncludeSpecificDenominations[len(m.IncludeSpecificDenominations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } @@ -12759,7 +12682,77 @@ func (m *AssetsRequest) Unmarshal(dAtA []byte) error { if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IncludeVotingReceiptTokens", wireType) } - var v int + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IncludeVotingReceiptTokens = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipView(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthView + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AssetsResponse) 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 ErrIntOverflowView + } + 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: AssetsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AssetsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DenomMetadata", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -12769,12 +12762,28 @@ func (m *AssetsRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - m.IncludeVotingReceiptTokens = bool(v != 0) + if msglen < 0 { + return ErrInvalidLengthView + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthView + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DenomMetadata == nil { + m.DenomMetadata = &v1alpha15.DenomMetadata{} + } + if err := m.DenomMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -12796,7 +12805,7 @@ func (m *AssetsRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *AssetsResponse) Unmarshal(dAtA []byte) error { +func (m *AppParametersRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12819,15 +12828,65 @@ func (m *AssetsResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AssetsResponse: wiretype end group for non-group") + return fmt.Errorf("proto: AppParametersRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AssetsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AppParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 2: + default: + iNdEx = preIndex + skippy, err := skipView(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthView + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppParametersResponse) 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 ErrIntOverflowView + } + 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: AppParametersResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DenomMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12854,10 +12913,10 @@ func (m *AssetsResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DenomMetadata == nil { - m.DenomMetadata = &v1alpha11.DenomMetadata{} + if m.Parameters == nil { + m.Parameters = &v1alpha110.AppParameters{} } - if err := m.DenomMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -12882,7 +12941,7 @@ func (m *AssetsResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ChainParametersRequest) Unmarshal(dAtA []byte) error { +func (m *GasPricesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12905,10 +12964,10 @@ func (m *ChainParametersRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ChainParametersRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GasPricesRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ChainParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GasPricesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -12932,7 +12991,7 @@ func (m *ChainParametersRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ChainParametersResponse) Unmarshal(dAtA []byte) error { +func (m *GasPricesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12955,15 +13014,15 @@ func (m *ChainParametersResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ChainParametersResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GasPricesResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ChainParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GasPricesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GasPrices", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12990,10 +13049,10 @@ func (m *ChainParametersResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Parameters == nil { - m.Parameters = &v1alpha14.ChainParameters{} + if m.GasPrices == nil { + m.GasPrices = &v1alpha12.GasPrices{} } - if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.GasPrices.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -13127,7 +13186,7 @@ func (m *FMDParametersResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Parameters == nil { - m.Parameters = &v1alpha14.FmdParameters{} + m.Parameters = &v1alpha111.FmdParameters{} } if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -13213,7 +13272,7 @@ func (m *NoteByCommitmentRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.NoteCommitment == nil { - m.NoteCommitment = &v1alpha11.StateCommitment{} + m.NoteCommitment = &v1alpha16.StateCommitment{} } if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -13239,41 +13298,6 @@ func (m *NoteByCommitmentRequest) Unmarshal(dAtA []byte) error { } } m.AwaitDetection = bool(v != 0) - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.AccountGroupId{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.XAccountGroupId = &NoteByCommitmentRequest_AccountGroupId{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -13440,7 +13464,7 @@ func (m *SwapByCommitmentRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.SwapCommitment == nil { - m.SwapCommitment = &v1alpha11.StateCommitment{} + m.SwapCommitment = &v1alpha16.StateCommitment{} } if err := m.SwapCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -13466,9 +13490,59 @@ func (m *SwapByCommitmentRequest) Unmarshal(dAtA []byte) error { } } m.AwaitDetection = bool(v != 0) - case 14: + default: + iNdEx = preIndex + skippy, err := skipView(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthView + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapByCommitmentResponse) 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 ErrIntOverflowView + } + 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: SwapByCommitmentResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapByCommitmentResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13495,11 +13569,12 @@ func (m *SwapByCommitmentRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha11.AccountGroupId{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Swap == nil { + m.Swap = &SwapRecord{} + } + if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.XAccountGroupId = &SwapByCommitmentRequest_AccountGroupId{v} iNdEx = postIndex default: iNdEx = preIndex @@ -13522,7 +13597,7 @@ func (m *SwapByCommitmentRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *SwapByCommitmentResponse) Unmarshal(dAtA []byte) error { +func (m *UnclaimedSwapsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13545,10 +13620,60 @@ func (m *SwapByCommitmentResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SwapByCommitmentResponse: wiretype end group for non-group") + return fmt.Errorf("proto: UnclaimedSwapsRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SwapByCommitmentResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UnclaimedSwapsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipView(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthView + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnclaimedSwapsResponse) 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 ErrIntOverflowView + } + 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: UnclaimedSwapsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnclaimedSwapsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -13667,7 +13792,7 @@ func (m *NullifierStatusRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Nullifier == nil { - m.Nullifier = &v1alpha11.Nullifier{} + m.Nullifier = &v1alpha112.Nullifier{} } if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -13693,41 +13818,6 @@ func (m *NullifierStatusRequest) Unmarshal(dAtA []byte) error { } } m.AwaitDetection = bool(v != 0) - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowView - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthView - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthView - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &v1alpha11.AccountGroupId{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.XAccountGroupId = &NullifierStatusRequest_AccountGroupId{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -13878,7 +13968,7 @@ func (m *TransactionInfoByHashRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Id == nil { - m.Id = &v1alpha1.Id{} + m.Id = &v1alpha11.TransactionId{} } if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -13938,7 +14028,7 @@ func (m *TransactionInfoRequest) Unmarshal(dAtA []byte) error { if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType) } - var v uint64 + m.StartHeight = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -13948,17 +14038,16 @@ func (m *TransactionInfoRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= uint64(b&0x7F) << shift + m.StartHeight |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.XStartHeight = &TransactionInfoRequest_StartHeight{v} case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndHeight", wireType) } - var v uint64 + m.EndHeight = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -13968,12 +14057,11 @@ func (m *TransactionInfoRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= uint64(b&0x7F) << shift + m.EndHeight |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.XEndHeight = &TransactionInfoRequest_EndHeight{v} default: iNdEx = preIndex skippy, err := skipView(dAtA[iNdEx:]) @@ -14028,7 +14116,7 @@ func (m *TransactionInfo) Unmarshal(dAtA []byte) error { if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) } - var v uint64 + m.Height = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -14038,12 +14126,11 @@ func (m *TransactionInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= uint64(b&0x7F) << shift + m.Height |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.XHeight = &TransactionInfo_Height{v} case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) @@ -14074,7 +14161,7 @@ func (m *TransactionInfo) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Id == nil { - m.Id = &v1alpha1.Id{} + m.Id = &v1alpha11.TransactionId{} } if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -14562,7 +14649,7 @@ func (m *NotesForVotingResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.IdentityKey == nil { - m.IdentityKey = &v1alpha11.IdentityKey{} + m.IdentityKey = &v1alpha13.IdentityKey{} } if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -14648,7 +14735,7 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.NoteCommitment == nil { - m.NoteCommitment = &v1alpha11.StateCommitment{} + m.NoteCommitment = &v1alpha16.StateCommitment{} } if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -14684,7 +14771,7 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Note == nil { - m.Note = &v1alpha11.Note{} + m.Note = &v1alpha113.Note{} } if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -14720,7 +14807,7 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.AddressIndex == nil { - m.AddressIndex = &v1alpha11.AddressIndex{} + m.AddressIndex = &v1alpha13.AddressIndex{} } if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -14756,7 +14843,7 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Nullifier == nil { - m.Nullifier = &v1alpha11.Nullifier{} + m.Nullifier = &v1alpha112.Nullifier{} } if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -14785,7 +14872,7 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error { if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field HeightSpent", wireType) } - var v uint64 + m.HeightSpent = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -14795,12 +14882,11 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= uint64(b&0x7F) << shift + m.HeightSpent |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.XHeightSpent = &SpendableNoteRecord_HeightSpent{v} case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) @@ -14850,7 +14936,7 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Source == nil { - m.Source = &v1alpha14.NoteSource{} + m.Source = &v1alpha112.CommitmentSource{} } if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -14936,7 +15022,7 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.SwapCommitment == nil { - m.SwapCommitment = &v1alpha11.StateCommitment{} + m.SwapCommitment = &v1alpha16.StateCommitment{} } if err := m.SwapCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -14972,7 +15058,7 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Swap == nil { - m.Swap = &v1alpha15.SwapPlaintext{} + m.Swap = &v1alpha19.SwapPlaintext{} } if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -15027,7 +15113,7 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Nullifier == nil { - m.Nullifier = &v1alpha11.Nullifier{} + m.Nullifier = &v1alpha112.Nullifier{} } if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -15063,7 +15149,7 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.OutputData == nil { - m.OutputData = &v1alpha15.BatchSwapOutputData{} + m.OutputData = &v1alpha19.BatchSwapOutputData{} } if err := m.OutputData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -15073,7 +15159,7 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error { if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field HeightClaimed", wireType) } - var v uint64 + m.HeightClaimed = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowView @@ -15083,12 +15169,11 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= uint64(b&0x7F) << shift + m.HeightClaimed |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.XHeightClaimed = &SwapRecord_HeightClaimed{v} case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) @@ -15119,7 +15204,7 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Source == nil { - m.Source = &v1alpha14.NoteSource{} + m.Source = &v1alpha112.CommitmentSource{} } if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -15204,11 +15289,12 @@ func (m *OwnedPositionIdsRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha15.PositionState{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.PositionState == nil { + m.PositionState = &v1alpha19.PositionState{} + } + if err := m.PositionState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.XPositionState = &OwnedPositionIdsRequest_PositionState{v} iNdEx = postIndex case 2: if wireType != 2 { @@ -15239,11 +15325,12 @@ func (m *OwnedPositionIdsRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v1alpha15.TradingPair{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.TradingPair == nil { + m.TradingPair = &v1alpha19.TradingPair{} + } + if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.XTradingPair = &OwnedPositionIdsRequest_TradingPair{v} iNdEx = postIndex default: iNdEx = preIndex @@ -15325,7 +15412,7 @@ func (m *OwnedPositionIdsResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.PositionId == nil { - m.PositionId = &v1alpha15.PositionId{} + m.PositionId = &v1alpha19.PositionId{} } if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err diff --git a/relayer/channel.go b/relayer/channel.go index 2f3f32b64..6a9c9e62d 100644 --- a/relayer/channel.go +++ b/relayer/channel.go @@ -5,8 +5,8 @@ import ( "fmt" "time" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - host "github.com/cosmos/ibc-go/v7/modules/core/24-host" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + host "github.com/cosmos/ibc-go/v8/modules/core/24-host" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" @@ -60,6 +60,8 @@ func (c *Chain) CreateOpenChannels( DefaultClientUpdateThreshold, DefaultFlushInterval, DefaultMaxMsgLength, + 0, + 0, ) c.log.Info("Starting event processor for channel handshake", @@ -133,6 +135,8 @@ func (c *Chain) CloseChannel( DefaultClientUpdateThreshold, DefaultFlushInterval, DefaultMaxMsgLength, + 0, + 0, )). WithInitialBlockHistory(0). WithMessageLifecycle(&processor.FlushLifecycle{}). @@ -171,6 +175,8 @@ func (c *Chain) CloseChannel( DefaultClientUpdateThreshold, DefaultFlushInterval, DefaultMaxMsgLength, + 0, + 0, )). WithInitialBlockHistory(0). WithMessageLifecycle(&processor.ChannelCloseLifecycle{ diff --git a/relayer/client.go b/relayer/client.go index 763bfa60b..0ede07737 100644 --- a/relayer/client.go +++ b/relayer/client.go @@ -7,16 +7,24 @@ import ( "github.com/avast/retry-go/v4" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" - tmclient "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + tmclient "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" "golang.org/x/sync/errgroup" ) // CreateClients creates clients for src on dst and dst on src if the client ids are unspecified. -func (c *Chain) CreateClients(ctx context.Context, dst *Chain, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, override bool, customClientTrustingPeriod time.Duration, memo string) (string, string, error) { +func (c *Chain) CreateClients(ctx context.Context, + dst *Chain, + allowUpdateAfterExpiry, + allowUpdateAfterMisbehaviour, + override bool, + customClientTrustingPeriod, + maxClockDrift time.Duration, + customClientTrustingPeriodPercentage int64, + memo string) (string, string, error) { // Query the latest heights on src and dst and retry if the query fails var srch, dsth int64 if err := retry.Do(func() error { @@ -63,7 +71,12 @@ func (c *Chain) CreateClients(ctx context.Context, dst *Chain, allowUpdateAfterE eg.Go(func() error { var err error // Create client on src for dst if the client id is unspecified - clientSrc, err = CreateClient(egCtx, c, dst, srcUpdateHeader, dstUpdateHeader, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, override, customClientTrustingPeriod, overrideUnbondingPeriod, memo) + clientSrc, err = CreateClient(egCtx, c, dst, + srcUpdateHeader, dstUpdateHeader, + allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, + override, customClientTrustingPeriod, + overrideUnbondingPeriod, maxClockDrift, + customClientTrustingPeriodPercentage, memo) if err != nil { return fmt.Errorf("failed to create client on src chain{%s}: %w", c.ChainID(), err) } @@ -73,7 +86,12 @@ func (c *Chain) CreateClients(ctx context.Context, dst *Chain, allowUpdateAfterE eg.Go(func() error { var err error // Create client on dst for src if the client id is unspecified - clientDst, err = CreateClient(egCtx, dst, c, dstUpdateHeader, srcUpdateHeader, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, override, customClientTrustingPeriod, overrideUnbondingPeriod, memo) + clientDst, err = CreateClient(egCtx, dst, c, + dstUpdateHeader, srcUpdateHeader, + allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, + override, customClientTrustingPeriod, + overrideUnbondingPeriod, maxClockDrift, + customClientTrustingPeriodPercentage, memo) if err != nil { return fmt.Errorf("failed to create client on dst chain{%s}: %w", dst.ChainID(), err) } @@ -101,11 +119,13 @@ func CreateClient( ctx context.Context, src, dst *Chain, srcUpdateHeader, dstUpdateHeader provider.IBCHeader, - allowUpdateAfterExpiry bool, - allowUpdateAfterMisbehaviour bool, + allowUpdateAfterExpiry, + allowUpdateAfterMisbehaviour, override bool, - customClientTrustingPeriod time.Duration, - overrideUnbondingPeriod time.Duration, + customClientTrustingPeriod, + overrideUnbondingPeriod, + maxClockDrift time.Duration, + customClientTrustingPeriodPercentage int64, memo string) (string, error) { // If a client ID was specified in the path and override is not set, ensure the client exists. if !override && src.PathEnd.ClientID != "" { @@ -126,7 +146,7 @@ func CreateClient( if tp == 0 { if err := retry.Do(func() error { var err error - tp, err = dst.GetTrustingPeriod(ctx, overrideUnbondingPeriod) + tp, err = dst.GetTrustingPeriod(ctx, overrideUnbondingPeriod, customClientTrustingPeriodPercentage) if err != nil { return fmt.Errorf("failed to get trusting period for chain{%s}: %w", dst.ChainID(), err) } @@ -164,7 +184,7 @@ func CreateClient( // We want to create a light client on the src chain which tracks the state of the dst chain. // So we build a new client state from dst and attempt to use this for creating the light client on src. - clientState, err := dst.ChainProvider.NewClientState(dst.ChainID(), dstUpdateHeader, tp, ubdPeriod, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour) + clientState, err := dst.ChainProvider.NewClientState(dst.ChainID(), dstUpdateHeader, tp, ubdPeriod, maxClockDrift, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour) if err != nil { return "", fmt.Errorf("failed to create new client state for chain{%s}: %w", dst.ChainID(), err) } @@ -215,6 +235,7 @@ func CreateClient( if err := retry.Do(func() error { var success bool var err error + res, success, err = src.ChainProvider.SendMessages(ctx, msgs, memo) if err != nil { src.LogFailedTx(res, err, msgs) @@ -525,6 +546,7 @@ func parseClientIDFromEvents(events []provider.RelayerEvent) (string, error) { } } } + return "", fmt.Errorf("client identifier event attribute not found") } @@ -532,6 +554,7 @@ type ClientStateInfo struct { ChainID string TrustingPeriod time.Duration LatestHeight ibcexported.Height + UnbondingTime time.Duration } func ClientInfoFromClientState(clientState *codectypes.Any) (ClientStateInfo, error) { @@ -546,6 +569,7 @@ func ClientInfoFromClientState(clientState *codectypes.Any) (ClientStateInfo, er ChainID: t.ChainId, TrustingPeriod: t.TrustingPeriod, LatestHeight: t.LatestHeight, + UnbondingTime: t.UnbondingPeriod, }, nil default: return ClientStateInfo{}, fmt.Errorf("unhandled client state type: (%T)", clientState) diff --git a/relayer/codecs/ethermint/chain_id.go b/relayer/codecs/ethermint/chain_id.go index 4d85416d0..947d5aa13 100644 --- a/relayer/codecs/ethermint/chain_id.go +++ b/relayer/codecs/ethermint/chain_id.go @@ -7,7 +7,7 @@ import ( "strings" errorsmod "cosmossdk.io/errors" - "github.com/cosmos/cosmos-sdk/types/errors" + legacyerrors "github.com/cosmos/cosmos-sdk/types/errors" ) var ( @@ -29,18 +29,18 @@ var ( func ParseChainID(chainID string) (*big.Int, error) { chainID = strings.TrimSpace(chainID) if len(chainID) > 48 { - return nil, errorsmod.Wrapf(errors.ErrInvalidChainID, "chain-id '%s' cannot exceed 48 chars", chainID) + return nil, errorsmod.Wrapf(legacyerrors.ErrInvalidChainID, "chain-id '%s' cannot exceed 48 chars", chainID) } matches := ethermintChainID.FindStringSubmatch(chainID) if matches == nil || len(matches) != 4 || matches[1] == "" { - return nil, errorsmod.Wrapf(errors.ErrInvalidChainID, "%s: %v", chainID, matches) + return nil, errorsmod.Wrapf(legacyerrors.ErrInvalidChainID, "%s: %v", chainID, matches) } // verify that the chain-id entered is a base 10 integer chainIDInt, ok := new(big.Int).SetString(matches[2], 10) if !ok { - return nil, errorsmod.Wrapf(errors.ErrInvalidChainID, "epoch %s must be base-10 integer format", matches[2]) + return nil, errorsmod.Wrapf(legacyerrors.ErrInvalidChainID, "epoch %s must be base-10 integer format", matches[2]) } return chainIDInt, nil diff --git a/relayer/codecs/ethermint/codec.go b/relayer/codecs/ethermint/codec.go index 65f4df8b9..7982abbdd 100644 --- a/relayer/codecs/ethermint/codec.go +++ b/relayer/codecs/ethermint/codec.go @@ -3,6 +3,7 @@ package ethermint import ( codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/tx" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" "github.com/cosmos/relayer/v2/relayer/ethermint" @@ -14,7 +15,7 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) { registry.RegisterImplementations((*cryptotypes.PrivKey)(nil), &PrivKey{}) registry.RegisterImplementations( - (*authtypes.AccountI)(nil), + (*sdk.AccountI)(nil), &EthAccount{}, ) registry.RegisterImplementations( diff --git a/relayer/codecs/ethermint/eip712.go b/relayer/codecs/ethermint/eip712.go index f2a862f99..9a5c17145 100644 --- a/relayer/codecs/ethermint/eip712.go +++ b/relayer/codecs/ethermint/eip712.go @@ -101,7 +101,19 @@ func decodeAminoSignDoc(signDocBytes []byte) (apitypes.TypedData, error) { msg := msgs[0] // By convention, the fee payer is the first address in the list of signers. - feePayer := msg.GetSigners()[0] + signers, _, err := protoCodec.GetMsgV1Signers(msg) + if err != nil { + return apitypes.TypedData{}, err + } + + signer := signers[0] + + var feePayer sdk.AccAddress + err = feePayer.Unmarshal(signer) + if err != nil { + return apitypes.TypedData{}, err + } + feeDelegation := &FeeDelegationOptions{ FeePayer: feePayer, } @@ -186,13 +198,23 @@ func decodeProtobufSignDoc(signDocBytes []byte) (apitypes.TypedData, error) { Gas: authInfo.Fee.GasLimit, } - feePayer := msg.GetSigners()[0] + signers, _, err := protoCodec.GetMsgV1Signers(msg) + if err != nil { + return apitypes.TypedData{}, err + } + + signer := signers[0] + + var feePayer sdk.AccAddress + err = feePayer.Unmarshal(signer) + if err != nil { + return apitypes.TypedData{}, err + } + feeDelegation := &FeeDelegationOptions{ FeePayer: feePayer, } - tip := authInfo.Tip - // WrapTxToTypedData expects the payload as an Amino Sign Doc signBytes := legacytx.StdSignBytes( signDoc.ChainId, @@ -202,7 +224,6 @@ func decodeProtobufSignDoc(signDocBytes []byte) (apitypes.TypedData, error) { *stdFee, msgs, body.Memo, - tip, ) typedData, err := WrapTxToTypedData( @@ -245,13 +266,26 @@ func validatePayloadMessages(msgs []sdk.Msg) error { return err } - if len(m.GetSigners()) != 1 { + signers, _, err := protoCodec.GetMsgV1Signers(m) + if err != nil { + return err + } + + if len(signers) != 1 { return errors.New("unable to build EIP-712 payload: expect exactly 1 signer") } + signer := signers[0] + + var feePayer sdk.AccAddress + err = feePayer.Unmarshal(signer) + if err != nil { + return err + } + if i == 0 { msgType = t - msgSigner = m.GetSigners()[0] + msgSigner = feePayer continue } @@ -259,7 +293,7 @@ func validatePayloadMessages(msgs []sdk.Msg) error { return errors.New("unable to build EIP-712 payload: different types of messages detected") } - if !msgSigner.Equals(m.GetSigners()[0]) { + if !msgSigner.Equals(feePayer) { return errors.New("unable to build EIP-712 payload: multiple signers detected") } } diff --git a/relayer/codecs/ethermint/encoding.go b/relayer/codecs/ethermint/encoding.go index 648548c06..2eb93a23a 100644 --- a/relayer/codecs/ethermint/encoding.go +++ b/relayer/codecs/ethermint/encoding.go @@ -17,7 +17,7 @@ import ( errorsmod "cosmossdk.io/errors" codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" - errortypes "github.com/cosmos/cosmos-sdk/types/errors" + legacyerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" @@ -36,7 +36,7 @@ func WrapTxToTypedData( txData := make(map[string]interface{}) if err := json.Unmarshal(data, &txData); err != nil { - return apitypes.TypedData{}, errorsmod.Wrap(errortypes.ErrJSONUnmarshal, "failed to JSON unmarshal data") + return apitypes.TypedData{}, errorsmod.Wrap(legacyerrors.ErrJSONUnmarshal, "failed to JSON unmarshal data") } domain := apitypes.TypedDataDomain{ @@ -55,7 +55,7 @@ func WrapTxToTypedData( if feeDelegation != nil { feeInfo, ok := txData["fee"].(map[string]interface{}) if !ok { - return apitypes.TypedData{}, errorsmod.Wrap(errortypes.ErrInvalidType, "cannot parse fee from tx data") + return apitypes.TypedData{}, errorsmod.Wrap(legacyerrors.ErrInvalidType, "cannot parse fee from tx data") } feeInfo["feePayer"] = feeDelegation.FeePayer.String() @@ -346,7 +346,7 @@ func jsonNameFromTag(tag reflect.StructTag) string { func unpackAny(cdc codectypes.AnyUnpacker, field reflect.Value) (reflect.Type, reflect.Value, error) { any, ok := field.Interface().(*codectypes.Any) if !ok { - return nil, reflect.Value{}, errorsmod.Wrapf(errortypes.ErrPackAny, "%T", field.Interface()) + return nil, reflect.Value{}, errorsmod.Wrapf(legacyerrors.ErrPackAny, "%T", field.Interface()) } anyWrapper := &cosmosAnyWrapper{ @@ -392,7 +392,7 @@ var ( addressType = reflect.TypeOf(common.Address{}) bigIntType = reflect.TypeOf(big.Int{}) cosmIntType = reflect.TypeOf(sdkmath.Int{}) - cosmDecType = reflect.TypeOf(sdk.Dec{}) + cosmDecType = reflect.TypeOf(sdkmath.LegacyDec{}) cosmosAnyType = reflect.TypeOf(&codectypes.Any{}) timeType = reflect.TypeOf(time.Time{}) diff --git a/relayer/codecs/ethermint/ethsecp256k1.go b/relayer/codecs/ethermint/ethsecp256k1.go index 22dbbb68f..089b427af 100644 --- a/relayer/codecs/ethermint/ethsecp256k1.go +++ b/relayer/codecs/ethermint/ethsecp256k1.go @@ -10,7 +10,7 @@ import ( tmcrypto "github.com/cometbft/cometbft/crypto" "github.com/cosmos/cosmos-sdk/codec" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" - errortypes "github.com/cosmos/cosmos-sdk/types/errors" + legacyerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/crypto" ) @@ -182,7 +182,7 @@ func (pubKey PubKey) MarshalAmino() ([]byte, error) { // UnmarshalAmino overrides Amino binary marshaling. func (pubKey *PubKey) UnmarshalAmino(bz []byte) error { if len(bz) != PubKeySize { - return errorsmod.Wrapf(errortypes.ErrInvalidPubKey, "invalid pubkey size, expected %d, got %d", PubKeySize, len(bz)) + return errorsmod.Wrapf(legacyerrors.ErrInvalidPubKey, "invalid pubkey size, expected %d, got %d", PubKeySize, len(bz)) } pubKey.Key = bz diff --git a/relayer/codecs/injective/codec.go b/relayer/codecs/injective/codec.go index dbed78978..daaf444bf 100644 --- a/relayer/codecs/injective/codec.go +++ b/relayer/codecs/injective/codec.go @@ -3,6 +3,7 @@ package injective import ( codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" + "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" ) @@ -20,10 +21,10 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) { registry.RegisterImplementations((*cryptotypes.PubKey)(nil), &PubKey{}) registry.RegisterImplementations((*cryptotypes.PrivKey)(nil), &PrivKey{}) - registry.RegisterInterface("injective.types.v1beta1.EthAccount", (*authtypes.AccountI)(nil)) + registry.RegisterInterface("injective.types.v1beta1.EthAccount", (*types.AccountI)(nil)) registry.RegisterImplementations( - (*authtypes.AccountI)(nil), + (*types.AccountI)(nil), &EthAccount{}, ) diff --git a/relayer/codecs/injective/ethsecp256k1.go b/relayer/codecs/injective/ethsecp256k1.go index 7face8727..53bdbbc41 100644 --- a/relayer/codecs/injective/ethsecp256k1.go +++ b/relayer/codecs/injective/ethsecp256k1.go @@ -6,14 +6,13 @@ import ( "crypto/subtle" "fmt" - ethcrypto "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/crypto/secp256k1" - + "cosmossdk.io/errors" + tmcrypto "github.com/cometbft/cometbft/crypto" "github.com/cosmos/cosmos-sdk/codec" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" - - tmcrypto "github.com/cometbft/cometbft/crypto" + ethcrypto "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/secp256k1" ) const ( @@ -169,7 +168,7 @@ func (pubKey PubKey) MarshalAmino() ([]byte, error) { // UnmarshalAmino overrides Amino binary marshalling. func (pubKey *PubKey) UnmarshalAmino(bz []byte) error { if len(bz) != PubKeySize { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidPubKey, "invalid pubkey size, expected %d, got %d", PubKeySize, len(bz)) + return errors.Wrapf(sdkerrors.ErrInvalidPubKey, "invalid pubkey size, expected %d, got %d", PubKeySize, len(bz)) } pubKey.Key = bz diff --git a/relayer/codecs/injective/evm.pb.go b/relayer/codecs/injective/evm.pb.go index 920446c72..1bce25563 100644 --- a/relayer/codecs/injective/evm.pb.go +++ b/relayer/codecs/injective/evm.pb.go @@ -4,8 +4,8 @@ package injective import ( + github_com_cosmos_cosmos_sdk_types "cosmossdk.io/math" fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" io "io" diff --git a/relayer/connection.go b/relayer/connection.go index df784d504..cb7aa3875 100644 --- a/relayer/connection.go +++ b/relayer/connection.go @@ -4,7 +4,7 @@ import ( "context" "time" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" @@ -41,6 +41,8 @@ func (c *Chain) CreateOpenConnections( DefaultClientUpdateThreshold, DefaultFlushInterval, DefaultMaxMsgLength, + 0, + 0, ) var connectionSrc, connectionDst string diff --git a/relayer/ethermint/dynamic_fee.pb.go b/relayer/ethermint/dynamic_fee.pb.go index 3238cd863..2065276c9 100644 --- a/relayer/ethermint/dynamic_fee.pb.go +++ b/relayer/ethermint/dynamic_fee.pb.go @@ -4,8 +4,8 @@ package ethermint import ( + cosmossdk_io_math "cosmossdk.io/math" fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" io "io" @@ -29,7 +29,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type ExtensionOptionDynamicFeeTx struct { // max_priority_price is the same as `max_priority_fee_per_gas` in eip-1559 // spec - MaxPriorityPrice github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=max_priority_price,json=maxPriorityPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_priority_price"` + MaxPriorityPrice cosmossdk_io_math.Int `protobuf:"bytes,1,opt,name=max_priority_price,json=maxPriorityPrice,proto3,customtype=cosmossdk.io/math.Int" json:"max_priority_price"` } func (m *ExtensionOptionDynamicFeeTx) Reset() { *m = ExtensionOptionDynamicFeeTx{} } @@ -74,22 +74,23 @@ func init() { } var fileDescriptor_9d7cf05c9992c480 = []byte{ - // 239 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x49, 0x2d, 0xc9, 0x48, - 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2f, 0x33, 0xd4, 0x4f, - 0xa9, 0xcc, 0x4b, 0xcc, 0xcd, 0x4c, 0x8e, 0x4f, 0x4b, 0x4d, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, - 0x17, 0x12, 0x82, 0xab, 0xd2, 0x03, 0xab, 0xd2, 0x2b, 0x33, 0x94, 0x12, 0x49, 0xcf, 0x4f, 0xcf, - 0x07, 0x4b, 0xeb, 0x83, 0x58, 0x10, 0x95, 0x4a, 0xd5, 0x5c, 0xd2, 0xae, 0x15, 0x25, 0xa9, 0x79, - 0xc5, 0x99, 0xf9, 0x79, 0xfe, 0x05, 0x25, 0x99, 0xf9, 0x79, 0x2e, 0x10, 0xd3, 0xdc, 0x52, 0x53, - 0x43, 0x2a, 0x84, 0x62, 0xb8, 0x84, 0x72, 0x13, 0x2b, 0xe2, 0x0b, 0x8a, 0x32, 0xf3, 0x8b, 0x32, - 0x4b, 0x2a, 0x41, 0x8c, 0xe4, 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x4e, 0x27, 0xbd, 0x13, 0xf7, - 0xe4, 0x19, 0x6e, 0xdd, 0x93, 0x57, 0x4b, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, - 0xd5, 0x4f, 0xce, 0x2f, 0xce, 0xcd, 0x2f, 0x86, 0x52, 0xba, 0xc5, 0x29, 0xd9, 0x10, 0x57, 0xea, - 0x79, 0xe6, 0x95, 0x04, 0x09, 0xe4, 0x26, 0x56, 0x04, 0x40, 0x0d, 0x0a, 0x00, 0x99, 0xe3, 0xe4, - 0x71, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, - 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0x7a, 0x98, 0x66, 0x16, 0xa5, - 0xe6, 0x24, 0x56, 0xa6, 0x16, 0xe9, 0x97, 0x19, 0xc1, 0x99, 0x70, 0x5f, 0x26, 0xb1, 0x81, 0x7d, - 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x84, 0x4e, 0x20, 0x90, 0x1f, 0x01, 0x00, 0x00, + // 242 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x3c, 0x8f, 0xb1, 0x4a, 0xc4, 0x40, + 0x10, 0x86, 0xb3, 0x8d, 0x60, 0x2a, 0x09, 0x0a, 0xa2, 0xb8, 0x27, 0x62, 0x61, 0xb5, 0xcb, 0xe9, + 0x1b, 0x1c, 0x2a, 0x8a, 0x85, 0x87, 0x58, 0xd9, 0x1c, 0x7b, 0xb9, 0x31, 0x19, 0x75, 0x77, 0xc2, + 0xee, 0x18, 0x92, 0xb7, 0xf0, 0xb1, 0xae, 0xbc, 0x52, 0x2c, 0x0e, 0x49, 0x5e, 0x44, 0x92, 0x48, + 0xba, 0x0f, 0xe6, 0xfb, 0x7f, 0xe6, 0x8f, 0xcf, 0x81, 0x73, 0xf0, 0x16, 0x1d, 0x6b, 0xae, 0x0b, + 0x08, 0xba, 0x9c, 0xea, 0x55, 0xed, 0x8c, 0xc5, 0x74, 0xf1, 0x0a, 0xa0, 0x0a, 0x4f, 0x4c, 0x49, + 0x32, 0x5a, 0xaa, 0xb7, 0x54, 0x39, 0x3d, 0xda, 0xcf, 0x28, 0xa3, 0xfe, 0xac, 0x3b, 0x1a, 0xcc, + 0xb3, 0xb7, 0xf8, 0xf8, 0xa6, 0x62, 0x70, 0x01, 0xc9, 0x3d, 0x16, 0x8c, 0xe4, 0xae, 0x87, 0xb6, + 0x5b, 0x80, 0xe7, 0x2a, 0x79, 0x88, 0x13, 0x6b, 0xaa, 0x45, 0xe1, 0x91, 0x3c, 0x72, 0xdd, 0x41, + 0x0a, 0x87, 0xe2, 0x54, 0x5c, 0xec, 0xce, 0x4e, 0xd6, 0xdb, 0x49, 0xf4, 0xb3, 0x9d, 0x1c, 0xa4, + 0x14, 0x2c, 0x85, 0xb0, 0x7a, 0x57, 0x48, 0xda, 0x1a, 0xce, 0xd5, 0xbd, 0xe3, 0xa7, 0x3d, 0x6b, + 0xaa, 0xf9, 0x7f, 0x6e, 0xde, 0xc5, 0x66, 0x77, 0xeb, 0x46, 0x8a, 0x4d, 0x23, 0xc5, 0x6f, 0x23, + 0xc5, 0x57, 0x2b, 0xa3, 0x4d, 0x2b, 0xa3, 0xef, 0x56, 0x46, 0x2f, 0x2a, 0x43, 0xce, 0x3f, 0x97, + 0x2a, 0x25, 0xab, 0x87, 0x36, 0xed, 0xe1, 0xc3, 0xd4, 0xe0, 0x75, 0x79, 0x39, 0xe2, 0x38, 0x6a, + 0xb9, 0xd3, 0x3f, 0x7f, 0xf5, 0x17, 0x00, 0x00, 0xff, 0xff, 0x11, 0x95, 0x9c, 0xff, 0x0e, 0x01, + 0x00, 0x00, } func (m *ExtensionOptionDynamicFeeTx) Marshal() (dAtA []byte, err error) { diff --git a/relayer/events.go b/relayer/events.go index 799844e89..b997d6b63 100644 --- a/relayer/events.go +++ b/relayer/events.go @@ -3,9 +3,9 @@ package relayer import ( "fmt" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - connectiontypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + connectiontypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/provider" ) diff --git a/relayer/ics24.go b/relayer/ics24.go index 993f60895..55da5ec6e 100644 --- a/relayer/ics24.go +++ b/relayer/ics24.go @@ -3,7 +3,7 @@ package relayer import ( "fmt" - host "github.com/cosmos/ibc-go/v7/modules/core/24-host" + host "github.com/cosmos/ibc-go/v8/modules/core/24-host" ) // Vclient validates the client identifier in the path diff --git a/relayer/log-chain.go b/relayer/log-chain.go index 752d945b4..d0379d999 100644 --- a/relayer/log-chain.go +++ b/relayer/log-chain.go @@ -7,7 +7,7 @@ import ( "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" ) func logFailedTx(log *zap.Logger, chainID string, res *provider.RelayerTxResponse, err error, msgs []provider.RelayerMessage) { diff --git a/relayer/naive-strategy.go b/relayer/naive-strategy.go index c23415df8..72ee89a20 100644 --- a/relayer/naive-strategy.go +++ b/relayer/naive-strategy.go @@ -6,7 +6,7 @@ import ( "sync" "github.com/avast/retry-go/v4" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" "golang.org/x/sync/errgroup" diff --git a/relayer/packet-tx.go b/relayer/packet-tx.go index 1cb38c7b3..490f18394 100644 --- a/relayer/packet-tx.go +++ b/relayer/packet-tx.go @@ -6,19 +6,26 @@ import ( "time" sdk "github.com/cosmos/cosmos-sdk/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" ) const defaultTimeoutOffset = 1000 -// SendTransferMsg initiates an ics20 transfer from src to dst with the specified args -// -//nolint:lll -func (c *Chain) SendTransferMsg(ctx context.Context, log *zap.Logger, dst *Chain, amount sdk.Coin, dstAddr string, toHeightOffset uint64, toTimeOffset time.Duration, srcChannel *chantypes.IdentifiedChannel) error { +// SendTransferMsg initiates an ics20 transfer from src to dst with the specified args. +func (c *Chain) SendTransferMsg( + ctx context.Context, + log *zap.Logger, + dst *Chain, + amount sdk.Coin, + dstAddr, memo string, + toHeightOffset uint64, + toTimeOffset time.Duration, + srcChannel *chantypes.IdentifiedChannel, +) error { var ( timeoutHeight uint64 timeoutTimestamp uint64 @@ -41,21 +48,29 @@ func (c *Chain) SendTransferMsg(ctx context.Context, log *zap.Logger, dst *Chain if err != nil { return fmt.Errorf("failed to query the client state response: %w", err) } + clientState, err := clienttypes.UnpackClientState(clientStateRes.ClientState) if err != nil { return fmt.Errorf("failed to unpack client state: %w", err) } - consensusStateRes, err := dst.ChainProvider.QueryClientConsensusState(ctx, dsth, dst.ClientID(), clientState.GetLatestHeight()) + + consensusStateRes, err := dst.ChainProvider.QueryClientConsensusState( + ctx, + dsth, + dst.ClientID(), + clientState.GetLatestHeight(), + ) if err != nil { return fmt.Errorf("failed to query client consensus state: %w", err) } + consensusState, err = clienttypes.UnpackConsensusState(consensusStateRes.ConsensusState) if err != nil { return fmt.Errorf("failed to unpack consensus state: %w", err) } // use local clock time as reference time if it is later than the - // consensus state timestamp of the counter party chain, otherwise + // consensus state timestamp of the counterparty chain, otherwise // still use consensus state timestamp as reference. // see https://github.com/cosmos/ibc-go/blob/ccc4cb804843f1a80acfb0d4dbf106d1ff2178bb/modules/apps/transfer/client/cli/tx.go#L94-L110 tmpNow := time.Now().UnixNano() @@ -93,6 +108,7 @@ func (c *Chain) SendTransferMsg(ctx context.Context, log *zap.Logger, dst *Chain }, TimeoutTimestamp: timeoutTimestamp, } + msg, err := c.ChainProvider.MsgTransfer(dstAddr, amount, pi) if err != nil { return err @@ -102,7 +118,7 @@ func (c *Chain) SendTransferMsg(ctx context.Context, log *zap.Logger, dst *Chain Src: []provider.RelayerMessage{msg}, } - result := txs.Send(ctx, log, AsRelayMsgSender(c), AsRelayMsgSender(dst), "") + result := txs.Send(ctx, log, AsRelayMsgSender(c), AsRelayMsgSender(dst), memo) if err := result.Error(); err != nil { if result.PartiallySent() { c.log.Info( @@ -113,15 +129,14 @@ func (c *Chain) SendTransferMsg(ctx context.Context, log *zap.Logger, dst *Chain ) } return err - } else { - if result.SuccessfullySent() { - c.log.Info( - "Successfully sent a transfer", - zap.String("src_chain_id", c.ChainID()), - zap.String("dst_chain_id", dst.ChainID()), - zap.Object("send_result", result), - ) - } + } else if result.SuccessfullySent() { + c.log.Info( + "Successfully sent a transfer", + zap.String("src_chain_id", c.ChainID()), + zap.String("dst_chain_id", dst.ChainID()), + zap.Object("send_result", result), + ) } + return nil } diff --git a/relayer/path.go b/relayer/path.go index 228544c4b..57b23a9b4 100644 --- a/relayer/path.go +++ b/relayer/path.go @@ -3,17 +3,19 @@ package relayer import ( "context" "fmt" + "strings" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" "github.com/cosmos/relayer/v2/relayer/processor" "golang.org/x/sync/errgroup" "gopkg.in/yaml.v3" ) const ( - check = "✔" - xIcon = "✘" + check = "✔" + xIcon = "✘" + Expired = "EXPIRED" ) // Paths represent connection paths between chains @@ -249,6 +251,23 @@ func (p *Path) QueryPathStatus(ctx context.Context, src, dst *Chain) *PathWithSt if err := eg.Wait(); err != nil || srcCs == nil || dstCs == nil { return out } + + srcExpiration, srcClientInfo, errSrc := QueryClientExpiration(ctx, src, dst) + if errSrc != nil { + return out + } + + dstExpiration, dstClientInfo, errDst := QueryClientExpiration(ctx, dst, src) + if errDst != nil { + return out + } + + srcData := SPrintClientExpiration(src, srcExpiration, srcClientInfo) + dstData := SPrintClientExpiration(dst, dstExpiration, dstClientInfo) + + if strings.Contains(srcData, Expired) || strings.Contains(dstData, Expired) { + return out + } out.Status.Clients = true eg, egCtx = errgroup.WithContext(ctx) diff --git a/relayer/pathEnd.go b/relayer/pathEnd.go index 1a7ac733f..1471cee84 100644 --- a/relayer/pathEnd.go +++ b/relayer/pathEnd.go @@ -3,7 +3,7 @@ package relayer import ( "strings" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" ) // PathEnd represents the local connection identifiers for a relay path diff --git a/relayer/pathEnd_test.go b/relayer/pathEnd_test.go index 9ff719468..3536ba2d5 100644 --- a/relayer/pathEnd_test.go +++ b/relayer/pathEnd_test.go @@ -3,7 +3,7 @@ package relayer import ( "testing" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/stretchr/testify/require" ) diff --git a/relayer/processor/message_processor.go b/relayer/processor/message_processor.go index c73bab303..b13ffa7cc 100644 --- a/relayer/processor/message_processor.go +++ b/relayer/processor/message_processor.go @@ -8,9 +8,9 @@ import ( "sync" "time" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + legacyerrors "github.com/cosmos/cosmos-sdk/types/errors" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" "go.uber.org/zap/zapcore" @@ -35,7 +35,13 @@ type messageProcessor struct { } // catagories of tx errors for a Prometheus counter. If the error doesnt fall into one of the below categories, it is labeled as "Tx Failure" -var promErrorCatagories = []error{chantypes.ErrRedundantTx, sdkerrors.ErrInsufficientFunds, sdkerrors.ErrInvalidCoins, sdkerrors.ErrOutOfGas, sdkerrors.ErrWrongSequence} +var promErrorCatagories = []error{ + chantypes.ErrRedundantTx, + legacyerrors.ErrInsufficientFunds, + legacyerrors.ErrInvalidCoins, + legacyerrors.ErrOutOfGas, + legacyerrors.ErrWrongSequence, +} // trackMessage stores the message tracker in the correct slice and index based on the type. func (mp *messageProcessor) trackMessage(tracker messageToTrack, i int) { @@ -94,7 +100,7 @@ func (mp *messageProcessor) processMessages( var needsClientUpdate bool // Localhost IBC does not permit client updates - if src.clientState.ClientID != ibcexported.LocalhostClientID && dst.clientState.ClientID != ibcexported.LocalhostConnectionID { + if !isLocalhostClient(src.clientState.ClientID, dst.clientState.ClientID) { var err error needsClientUpdate, err = mp.shouldUpdateClientNow(ctx, src, dst) if err != nil { @@ -111,6 +117,14 @@ func (mp *messageProcessor) processMessages( return mp.trackAndSendMessages(ctx, src, dst, needsClientUpdate) } +func isLocalhostClient(srcClientID, dstClientID string) bool { + if srcClientID == ibcexported.LocalhostClientID && dstClientID == ibcexported.LocalhostConnectionID { + return true + } + + return false +} + // shouldUpdateClientNow determines if an update client message should be sent // even if there are no messages to be sent now. It will not be attempted if // there has not been enough blocks since the last client update attempt. @@ -118,6 +132,7 @@ func (mp *messageProcessor) processMessages( // or the configured client update threshold duration has passed. func (mp *messageProcessor) shouldUpdateClientNow(ctx context.Context, src, dst *pathEndRuntime) (bool, error) { var consensusHeightTime time.Time + if dst.clientState.ConsensusTime.IsZero() { h, err := src.chainProvider.QueryIBCHeader(ctx, int64(dst.clientState.ConsensusHeight.RevisionHeight)) if err != nil { @@ -240,6 +255,7 @@ func (mp *messageProcessor) assembleMsgUpdateClient(ctx context.Context, src, ds clientID := dst.info.ClientID clientConsensusHeight := dst.clientState.ConsensusHeight trustedConsensusHeight := dst.clientTrustedState.ClientState.ConsensusHeight + var trustedNextValidatorsHash []byte if dst.clientTrustedState.IBCHeader != nil { trustedNextValidatorsHash = dst.clientTrustedState.IBCHeader.NextValidatorsHash() @@ -254,11 +270,13 @@ func (mp *messageProcessor) assembleMsgUpdateClient(ctx context.Context, src, ds return fmt.Errorf("observed client trusted height: %d does not equal latest client state height: %d", trustedConsensusHeight.RevisionHeight, clientConsensusHeight.RevisionHeight) } + header, err := src.chainProvider.QueryIBCHeader(ctx, int64(clientConsensusHeight.RevisionHeight+1)) if err != nil { return fmt.Errorf("error getting IBC header at height: %d for chain_id: %s, %w", clientConsensusHeight.RevisionHeight+1, src.info.ChainID, err) } + mp.log.Debug("Had to query for client trusted IBC header", zap.String("path_name", src.info.PathName), zap.String("chain_id", src.info.ChainID), @@ -267,10 +285,12 @@ func (mp *messageProcessor) assembleMsgUpdateClient(ctx context.Context, src, ds zap.Uint64("height", clientConsensusHeight.RevisionHeight+1), zap.Uint64("latest_height", src.latestBlock.Height), ) + dst.clientTrustedState = provider.ClientTrustedState{ ClientState: dst.clientState, IBCHeader: header, } + trustedConsensusHeight = clientConsensusHeight trustedNextValidatorsHash = header.NextValidatorsHash() } @@ -316,6 +336,7 @@ func (mp *messageProcessor) trackAndSendMessages( retries := dst.trackProcessingMessage(t) if t.assembledMsg() == nil { + dst.trackFinishedProcessingMessage(t) continue } @@ -339,7 +360,7 @@ func (mp *messageProcessor) trackAndSendMessages( return nil } - if needsClientUpdate { + if needsClientUpdate && mp.msgUpdateClient != nil { go mp.sendClientUpdate(ctx, src, dst) return nil } @@ -374,15 +395,7 @@ func (mp *messageProcessor) sendClientUpdate( zap.Error(err), ) - for _, promError := range promErrorCatagories { - if mp.metrics != nil { - if errors.Is(err, promError) { - mp.metrics.IncTxFailure(src.info.PathName, src.info.ChainID, promError.Error()) - } else { - mp.metrics.IncTxFailure(src.info.PathName, src.info.ChainID, "Tx Failure") - } - } - } + mp.metricParseTxFailureCatagory(err, src) return } dst.log.Debug("Client update broadcast completed") @@ -422,6 +435,7 @@ func (mp *messageProcessor) sendBatchMessages( // messages are batch with appended MsgUpdateClient msgs = make([]provider.RelayerMessage, 1+len(batch)) msgs[0] = mp.msgUpdateClient + for i, t := range batch { msgs[i+1] = t.assembledMsg() fields = append(fields, zap.Object(fmt.Sprintf("msg_%d", i), t)) @@ -431,6 +445,9 @@ func (mp *messageProcessor) sendBatchMessages( dst.log.Debug("Will relay messages", fields...) callback := func(_ *provider.RelayerTxResponse, err error) { + for _, t := range batch { + dst.finishedProcessing <- t + } // only increment metrics counts for successful packets if err != nil || mp.metrics == nil { return @@ -468,6 +485,9 @@ func (mp *messageProcessor) sendBatchMessages( } if err := dst.chainProvider.SendMessagesToMempool(broadcastCtx, msgs, mp.memo, ctx, callbacks); err != nil { + for _, t := range batch { + dst.finishedProcessing <- t + } errFields := []zapcore.Field{ zap.String("path_name", src.info.PathName), zap.String("src_chain_id", src.info.ChainID), @@ -477,15 +497,7 @@ func (mp *messageProcessor) sendBatchMessages( zap.Error(err), } - for _, promError := range promErrorCatagories { - if mp.metrics != nil { - if errors.Is(err, promError) { - mp.metrics.IncTxFailure(src.info.PathName, src.info.ChainID, promError.Error()) - } else { - mp.metrics.IncTxFailure(src.info.PathName, src.info.ChainID, "Tx Failure") - } - } - } + mp.metricParseTxFailureCatagory(err, src) if errors.Is(err, chantypes.ErrRedundantTx) { mp.log.Debug("Redundant message(s)", errFields...) @@ -520,26 +532,31 @@ func (mp *messageProcessor) sendSingleMessage( // Set callback for packet messages so that we increment prometheus metrics on successful relays. callbacks := []func(rtr *provider.RelayerTxResponse, err error){} - if t, ok := tracker.(packetMessageToTrack); ok { - callback := func(_ *provider.RelayerTxResponse, err error) { - // only increment metrics counts for successful packets - if err != nil || mp.metrics == nil { - return - } - var channel, port string - if t.msg.eventType == chantypes.EventTypeRecvPacket { - channel = t.msg.info.DestChannel - port = t.msg.info.DestPort - } else { - channel = t.msg.info.SourceChannel - port = t.msg.info.SourcePort - } - mp.metrics.IncPacketsRelayed(dst.info.PathName, dst.info.ChainID, channel, port, t.msg.eventType) - } - callbacks = append(callbacks, callback) + callback := func(_ *provider.RelayerTxResponse, err error) { + dst.finishedProcessing <- tracker + + t, ok := tracker.(packetMessageToTrack) + if !ok { + return + } + // only increment metrics counts for successful packets + if err != nil || mp.metrics == nil { + return + } + var channel, port string + if t.msg.eventType == chantypes.EventTypeRecvPacket { + channel = t.msg.info.DestChannel + port = t.msg.info.DestPort + } else { + channel = t.msg.info.SourceChannel + port = t.msg.info.SourcePort + } + mp.metrics.IncPacketsRelayed(dst.info.PathName, dst.info.ChainID, channel, port, t.msg.eventType) } + callbacks = append(callbacks, callback) + //During testing, this adds a callback so our test case can inspect the TX results if PathProcMessageCollector != nil { testCallback := func(rtr *provider.RelayerTxResponse, err error) { @@ -556,6 +573,7 @@ func (mp *messageProcessor) sendSingleMessage( err := dst.chainProvider.SendMessagesToMempool(broadcastCtx, msgs, mp.memo, ctx, callbacks) if err != nil { + dst.finishedProcessing <- tracker errFields := []zapcore.Field{ zap.String("path_name", src.info.PathName), zap.String("src_chain_id", src.info.ChainID), @@ -564,15 +582,7 @@ func (mp *messageProcessor) sendSingleMessage( zap.String("dst_client_id", dst.info.ClientID), } - for _, promError := range promErrorCatagories { - if mp.metrics != nil { - if errors.Is(err, promError) { - mp.metrics.IncTxFailure(src.info.PathName, src.info.ChainID, promError.Error()) - } else { - mp.metrics.IncTxFailure(src.info.PathName, src.info.ChainID, "Tx Failure") - } - } - } + mp.metricParseTxFailureCatagory(err, src) errFields = append(errFields, zap.Object("msg", tracker)) errFields = append(errFields, zap.Error(err)) @@ -586,3 +596,17 @@ func (mp *messageProcessor) sendSingleMessage( dst.log.Debug(fmt.Sprintf("Successfully broadcasted %s message", msgType), zap.Object("msg", tracker)) } + +func (mp *messageProcessor) metricParseTxFailureCatagory(err error, src *pathEndRuntime) { + if mp.metrics == nil { + return + } + + for _, promError := range promErrorCatagories { + if errors.Is(err, promError) { + mp.metrics.IncTxFailure(src.info.PathName, src.info.ChainID, promError.Error()) + return + } + } + mp.metrics.IncTxFailure(src.info.PathName, src.info.ChainID, "Tx Failure") +} diff --git a/relayer/processor/metrics.go b/relayer/processor/metrics.go index 1048eed1e..2630fcd2b 100644 --- a/relayer/processor/metrics.go +++ b/relayer/processor/metrics.go @@ -18,6 +18,8 @@ type PrometheusMetrics struct { BlockQueryFailure *prometheus.CounterVec ClientExpiration *prometheus.GaugeVec ClientTrustingPeriod *prometheus.GaugeVec + UnrelayedPackets *prometheus.GaugeVec + UnrelayedAcks *prometheus.GaugeVec } func (m *PrometheusMetrics) AddPacketsObserved(pathName, chain, channel, port, eventType string, count int) { @@ -56,6 +58,14 @@ func (m *PrometheusMetrics) IncTxFailure(pathName, chain, errDesc string) { m.TxFailureError.WithLabelValues(pathName, chain, errDesc).Inc() } +func (m *PrometheusMetrics) SetUnrelayedPackets(pathName, srcChain, destChain, srcChannel, destChannel string, unrelayedPackets int) { + m.UnrelayedPackets.WithLabelValues(pathName, srcChain, destChain, srcChannel, destChannel).Set(float64(unrelayedPackets)) +} + +func (m *PrometheusMetrics) SetUnrelayedAcks(pathName, srcChain, destChain, srcChannel, destChannel string, UnrelayedAcks int) { + m.UnrelayedAcks.WithLabelValues(pathName, srcChain, destChain, srcChannel, destChannel).Set(float64(UnrelayedAcks)) +} + func NewPrometheusMetrics() *PrometheusMetrics { packetLabels := []string{"path_name", "chain", "channel", "port", "type"} heightLabels := []string{"chain"} @@ -64,16 +74,17 @@ func NewPrometheusMetrics() *PrometheusMetrics { walletLabels := []string{"chain", "gas_price", "key", "address", "denom"} clientExpirationLables := []string{"path_name", "chain", "client_id", "trusting_period"} clientTrustingPeriodLables := []string{"path_name", "chain", "client_id"} + unrelayedSeqsLabels := []string{"path_name", "src_chain", "dest_chain", "src_channel", "dest_channel"} registry := prometheus.NewRegistry() registerer := promauto.With(registry) return &PrometheusMetrics{ Registry: registry, PacketObservedCounter: registerer.NewCounterVec(prometheus.CounterOpts{ - Name: "cosmos_relayer_observed_packets", + Name: "cosmos_relayer_observed_packets_total", Help: "The total number of observed packets", }, packetLabels), PacketRelayedCounter: registerer.NewCounterVec(prometheus.CounterOpts{ - Name: "cosmos_relayer_relayed_packets", + Name: "cosmos_relayer_relayed_packets_total", Help: "The total number of relayed packets", }, packetLabels), LatestHeightGauge: registerer.NewGaugeVec(prometheus.GaugeOpts{ @@ -104,5 +115,13 @@ func NewPrometheusMetrics() *PrometheusMetrics { Name: "cosmos_relayer_client_trusting_period_seconds", Help: "The trusting period (in seconds) of the client", }, clientTrustingPeriodLables), + UnrelayedPackets: registerer.NewGaugeVec(prometheus.GaugeOpts{ + Name: "cosmos_relayer_unrelayed_packets", + Help: "Current number of unrelayed packets on both the source and destination chains for a specific path and channel", + }, unrelayedSeqsLabels), + UnrelayedAcks: registerer.NewGaugeVec(prometheus.GaugeOpts{ + Name: "cosmos_relayer_unrelayed_acks", + Help: "Current number of unrelayed acknowledgements on both the source and destination chains for a specific path and channel", + }, unrelayedSeqsLabels), } } diff --git a/relayer/processor/path_end.go b/relayer/processor/path_end.go index 9ba05b542..815b8838c 100644 --- a/relayer/processor/path_end.go +++ b/relayer/processor/path_end.go @@ -67,27 +67,3 @@ func (pe PathEnd) shouldRelayChannelSingle(channelKey ChainChannelKey, listChann } return !allowList } - -// if port ID is empty on allowlist channel, allow all ports -// if port ID is non-empty on allowlist channel, allow only that specific port -// if port ID is empty on blocklist channel, block all ports -// if port ID is non-empty on blocklist channel, block only that specific port -func (pe PathEnd) ShouldRelayChannel(channelKey ChainChannelKey) bool { - if pe.Rule == RuleAllowList { - for _, allowedChannel := range pe.FilterList { - if pe.shouldRelayChannelSingle(channelKey, allowedChannel, true) { - return true - } - } - return false - } else if pe.Rule == RuleDenyList { - for _, blockedChannel := range pe.FilterList { - if !pe.shouldRelayChannelSingle(channelKey, blockedChannel, false) { - return false - } - } - return true - } - // if neither allow list or block list are provided, all channels are okay - return true -} diff --git a/relayer/processor/path_end_runtime.go b/relayer/processor/path_end_runtime.go index f1b732af7..687553eb6 100644 --- a/relayer/processor/path_end_runtime.go +++ b/relayer/processor/path_end_runtime.go @@ -2,13 +2,15 @@ package processor import ( "context" + "fmt" "sync" "time" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" ) @@ -30,6 +32,7 @@ type pathEndRuntime struct { clientTrustedState provider.ClientTrustedState connectionStateCache ConnectionStateCache channelStateCache ChannelStateCache + channelStateCacheMu sync.RWMutex channelOrderCache map[string]chantypes.Order latestHeader provider.IBCHeader ibcHeaderCache IBCHeaderCache @@ -42,7 +45,7 @@ type pathEndRuntime struct { packetProcessing packetProcessingCache connProcessing connectionProcessingCache channelProcessing channelProcessingCache - clientICQProcessing clientICQProcessingCache + clientICQProcessing *clientICQProcessingCache // Message subscriber callbacks connSubscribers map[string][]func(provider.ConnectionInfo) @@ -54,6 +57,8 @@ type pathEndRuntime struct { lastClientUpdateHeightMu sync.Mutex metrics *PrometheusMetrics + + finishedProcessing chan messageToTrack } func newPathEndRuntime(log *zap.Logger, pathEnd PathEnd, metrics *PrometheusMetrics) *pathEndRuntime { @@ -65,6 +70,7 @@ func newPathEndRuntime(log *zap.Logger, pathEnd PathEnd, metrics *PrometheusMetr ), info: pathEnd, incomingCacheData: make(chan ChainProcessorCacheData, 100), + finishedProcessing: make(chan messageToTrack, 1000), connectionStateCache: make(ConnectionStateCache), channelStateCache: make(ChannelStateCache), messageCache: NewIBCMessagesCache(), @@ -73,7 +79,7 @@ func newPathEndRuntime(log *zap.Logger, pathEnd PathEnd, metrics *PrometheusMetr connProcessing: make(connectionProcessingCache), channelProcessing: make(channelProcessingCache), channelOrderCache: make(map[string]chantypes.Order), - clientICQProcessing: make(clientICQProcessingCache), + clientICQProcessing: newClientICQProcessingCache(), connSubscribers: make(map[string][]func(provider.ConnectionInfo)), metrics: metrics, } @@ -97,25 +103,111 @@ func (pathEnd *pathEndRuntime) isRelevantChannel(channelID string) bool { return false } +// checkMemoLimit returns an error if the packet memo exceeds the configured limit. +func checkMemoLimit(packetData []byte, memoLimit int) error { + if memoLimit <= 0 { + // no limit + return nil + } + + var packet transfertypes.FungibleTokenPacketData + if err := transfertypes.ModuleCdc.UnmarshalJSON(packetData, &packet); err != nil { + // not an ICS-20 packet + return nil + } + + if len(packet.Memo) > memoLimit { + return fmt.Errorf("packet memo size: %d exceeds limit: %d", len(packet.Memo), memoLimit) + } + + return nil +} + +// checkMaxReceiverSize returns an error if the receiver field size exceeds the configured limit. +func checkMaxReceiverSize(packetData []byte, maxReceiverSize int) error { + if maxReceiverSize <= 0 { + // no limit + return nil + } + + var packet transfertypes.FungibleTokenPacketData + if err := transfertypes.ModuleCdc.UnmarshalJSON(packetData, &packet); err != nil { + // not an ICS-20 packet + return nil + } + + if len(packet.Receiver) > maxReceiverSize { + return fmt.Errorf("packet receiver size: %d exceeds limit: %d", len(packet.Receiver), maxReceiverSize) + } + + return nil +} + // mergeMessageCache merges relevant IBC messages for packet flows, connection handshakes, and channel handshakes. // inSync indicates whether both involved ChainProcessors are in sync or not. When true, the observed packets // metrics will be counted so that observed vs relayed packets can be compared. -func (pathEnd *pathEndRuntime) mergeMessageCache(messageCache IBCMessagesCache, counterpartyChainID string, inSync bool) { +func (pathEnd *pathEndRuntime) mergeMessageCache( + messageCache IBCMessagesCache, + counterpartyChainID string, + inSync bool, + memoLimit, maxReceiverSize int, +) { packetMessages := make(ChannelPacketMessagesCache) connectionHandshakeMessages := make(ConnectionMessagesCache) channelHandshakeMessages := make(ChannelMessagesCache) clientICQMessages := make(ClientICQMessagesCache) + messageCache.PacketState.Prune(100) // Only keep most recent 100 packet states per channel + for ch, pmc := range messageCache.PacketFlow { - if pathEnd.info.ShouldRelayChannel(ChainChannelKey{ChainID: pathEnd.info.ChainID, CounterpartyChainID: counterpartyChainID, ChannelKey: ch}) { - if inSync && pathEnd.metrics != nil { - for eventType, pCache := range pmc { - pathEnd.metrics.AddPacketsObserved(pathEnd.info.PathName, pathEnd.info.ChainID, ch.ChannelID, ch.PortID, eventType, len(pCache)) + if pathEnd.ShouldRelayChannel(ChainChannelKey{ + ChainID: pathEnd.info.ChainID, + CounterpartyChainID: counterpartyChainID, + ChannelKey: ch, + }) { + newPmc := make(PacketMessagesCache) + for eventType, pCache := range pmc { + if inSync && pathEnd.metrics != nil { + pathEnd.metrics.AddPacketsObserved( + pathEnd.info.PathName, + pathEnd.info.ChainID, + ch.ChannelID, + ch.PortID, + eventType, + len(pCache), + ) + } + + newPc := make(PacketSequenceCache) + for seq, p := range pCache { + if err := checkMemoLimit(p.Data, memoLimit); err != nil { + pathEnd.log.Warn("Ignoring packet", zap.Error(err)) + continue + } + + if err := checkMaxReceiverSize(p.Data, maxReceiverSize); err != nil { + pathEnd.log.Warn("Ignoring packet", zap.Error(err)) + continue + } + + newPc[seq] = p + } + + if len(newPc) > 0 { + newPmc[eventType] = newPc + } + } + + packetMessages[ch] = newPmc + + for eventType, pCache := range newPmc { + for seq := range pCache { + pathEnd.messageCache.PacketState.UpdateState(ch, seq, eventType) } } - packetMessages[ch] = pmc } } + pathEnd.messageCache.PacketFlow.Merge(packetMessages) for eventType, cmc := range messageCache.ConnectionHandshake { @@ -369,7 +461,16 @@ func (pathEnd *pathEndRuntime) checkForMisbehaviour( return true, nil } -func (pathEnd *pathEndRuntime) mergeCacheData(ctx context.Context, cancel func(), d ChainProcessorCacheData, counterpartyChainID string, counterpartyInSync bool, messageLifecycle MessageLifecycle, counterParty *pathEndRuntime) { +func (pathEnd *pathEndRuntime) mergeCacheData( + ctx context.Context, + cancel func(), + d ChainProcessorCacheData, + counterpartyChainID string, + counterpartyInSync bool, + messageLifecycle MessageLifecycle, + counterParty *pathEndRuntime, + memoLimit, maxReceiverSize int, +) { pathEnd.lastClientUpdateHeightMu.Lock() pathEnd.latestBlock = d.LatestBlock pathEnd.lastClientUpdateHeightMu.Unlock() @@ -403,9 +504,19 @@ func (pathEnd *pathEndRuntime) mergeCacheData(ctx context.Context, cancel func() } pathEnd.connectionStateCache = d.ConnectionStateCache // Update latest connection open state for chain - pathEnd.channelStateCache = d.ChannelStateCache // Update latest channel open state for chain - pathEnd.mergeMessageCache(d.IBCMessagesCache, counterpartyChainID, pathEnd.inSync && counterpartyInSync) // Merge incoming packet IBC messages into the backlog + pathEnd.channelStateCacheMu.Lock() + pathEnd.channelStateCache = d.ChannelStateCache // Update latest channel open state for chain + pathEnd.channelStateCacheMu.Unlock() + + // Merge incoming packet IBC messages into the backlog + pathEnd.mergeMessageCache( + d.IBCMessagesCache, + counterpartyChainID, + pathEnd.inSync && counterpartyInSync, + memoLimit, + maxReceiverSize, + ) pathEnd.ibcHeaderCache.Merge(d.IBCHeaderCache) // Update latest IBC header state pathEnd.ibcHeaderCache.Prune(ibcHeadersToCache) // Only keep most recent IBC headers @@ -428,7 +539,7 @@ func (pathEnd *pathEndRuntime) shouldSendPacketMessage(message packetIBCMessage, } pathEndForHeight := counterparty - if eventType == chantypes.EventTypeTimeoutPacket || eventType == chantypes.EventTypeTimeoutPacketOnClose { + if eventType == chantypes.EventTypeTimeoutPacket { pathEndForHeight = pathEnd } @@ -462,23 +573,21 @@ func (pathEnd *pathEndRuntime) shouldSendPacketMessage(message packetIBCMessage, // in progress cache does not exist for this eventType, so can send return true } - inProgress, ok := channelProcessingCache[sequence] - if !ok { + inProgress := channelProcessingCache.get(sequence) + if inProgress == nil { // in progress cache does not exist for this sequence, so can send. return true } + if inProgress.isProcessing() { + // this message is currently being processed (broadcasting), do not attempt to send again yet. + return false + } blocksSinceLastProcessed := pathEnd.latestBlock.Height - inProgress.lastProcessedHeight - if inProgress.assembled { - if blocksSinceLastProcessed < blocksToRetrySendAfter { - // this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet. - return false - } - } else { - if blocksSinceLastProcessed < blocksToRetryAssemblyAfter { - // this message was sent less than blocksToRetryAssemblyAfter ago, do not attempt assembly again yet. - return false - } + if inProgress.assembled && blocksSinceLastProcessed < blocksToRetrySendAfter { + // this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet. + return false } + if inProgress.retryCount >= maxMessageSendRetries { pathEnd.log.Error("Giving up on sending packet message after max retries", zap.String("event_type", eventType), @@ -509,19 +618,26 @@ func (pathEnd *pathEndRuntime) removePacketRetention( toDelete[preInitKey] = []uint64{sequence} case chantypes.EventTypeRecvPacket: toDelete[eventType] = []uint64{sequence} + toDelete[chantypes.EventTypeWriteAck] = []uint64{sequence} toDeleteCounterparty[chantypes.EventTypeSendPacket] = []uint64{sequence} - case chantypes.EventTypeAcknowledgePacket, chantypes.EventTypeTimeoutPacket, chantypes.EventTypeTimeoutPacketOnClose: + case chantypes.EventTypeAcknowledgePacket: toDelete[eventType] = []uint64{sequence} toDeleteCounterparty[chantypes.EventTypeRecvPacket] = []uint64{sequence} + toDeleteCounterparty[chantypes.EventTypeWriteAck] = []uint64{sequence} + toDelete[chantypes.EventTypeSendPacket] = []uint64{sequence} + case chantypes.EventTypeTimeoutPacket: + toDelete[eventType] = []uint64{sequence} toDelete[chantypes.EventTypeSendPacket] = []uint64{sequence} } + // delete in progress send for this specific message pathEnd.packetProcessing[k].deleteMessages(map[string][]uint64{ eventType: {sequence}, }) + // delete all packet flow retention history for this sequence pathEnd.messageCache.PacketFlow[k].DeleteMessages(toDelete) - counterparty.messageCache.PacketFlow[k].DeleteMessages(toDeleteCounterparty) + counterparty.messageCache.PacketFlow[k.Counterparty()].DeleteMessages(toDeleteCounterparty) } // shouldSendConnectionMessage determines if the connection handshake message should be sent now. @@ -544,22 +660,19 @@ func (pathEnd *pathEndRuntime) shouldSendConnectionMessage(message connectionIBC // in progress cache does not exist for this eventType, so can send. return true } - inProgress, ok := msgProcessCache[k] - if !ok { + inProgress := msgProcessCache.get(k) + if inProgress == nil { // in progress cache does not exist for this connection, so can send. return true } + if inProgress.isProcessing() { + // this message is currently being processed (broadcasting), do not attempt to send again yet. + return false + } blocksSinceLastProcessed := pathEnd.latestBlock.Height - inProgress.lastProcessedHeight - if inProgress.assembled { - if blocksSinceLastProcessed < blocksToRetrySendAfter { - // this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet. - return false - } - } else { - if blocksSinceLastProcessed < blocksToRetryAssemblyAfter { - // this message was sent less than blocksToRetryAssemblyAfter ago, do not attempt assembly again yet. - return false - } + if inProgress.assembled && blocksSinceLastProcessed < blocksToRetrySendAfter { + // this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet. + return false } if inProgress.retryCount >= maxMessageSendRetries { pathEnd.log.Error("Giving up on sending connection message after max retries", @@ -626,22 +739,19 @@ func (pathEnd *pathEndRuntime) shouldSendChannelMessage(message channelIBCMessag // in progress cache does not exist for this eventType, so can send. return true } - inProgress, ok := msgProcessCache[channelKey] - if !ok { + inProgress := msgProcessCache.get(channelKey) + if inProgress == nil { // in progress cache does not exist for this channel, so can send. return true } + if inProgress.isProcessing() { + // this message is currently being processed (broadcasting), do not attempt to send again yet. + return false + } blocksSinceLastProcessed := pathEnd.latestBlock.Height - inProgress.lastProcessedHeight - if inProgress.assembled { - if blocksSinceLastProcessed < blocksToRetrySendAfter { - // this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet. - return false - } - } else { - if blocksSinceLastProcessed < blocksToRetryAssemblyAfter { - // this message was sent less than blocksToRetryAssemblyAfter ago, do not attempt assembly again yet. - return false - } + if inProgress.assembled && blocksSinceLastProcessed < blocksToRetrySendAfter { + // this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet. + return false } if inProgress.retryCount >= maxMessageSendRetries { pathEnd.log.Error("Giving up on sending channel message after max retries", @@ -720,22 +830,19 @@ func (pathEnd *pathEndRuntime) shouldSendChannelMessage(message channelIBCMessag // It will also determine if the message needs to be given up on entirely and remove retention if so. func (pathEnd *pathEndRuntime) shouldSendClientICQMessage(message provider.ClientICQInfo) bool { queryID := message.QueryID - inProgress, ok := pathEnd.clientICQProcessing[queryID] - if !ok { + inProgress := pathEnd.clientICQProcessing.get(queryID) + if inProgress == nil { // in progress cache does not exist for this query ID, so can send. return true } + if inProgress.isProcessing() { + // this message is currently being processed (broadcasting), do not attempt to send again yet. + return false + } blocksSinceLastProcessed := pathEnd.latestBlock.Height - inProgress.lastProcessedHeight - if inProgress.assembled { - if blocksSinceLastProcessed < blocksToRetrySendAfter { - // this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet. - return false - } - } else { - if blocksSinceLastProcessed < blocksToRetryAssemblyAfter { - // this message was sent less than blocksToRetryAssemblyAfter ago, do not attempt assembly again yet. - return false - } + if inProgress.assembled && blocksSinceLastProcessed < blocksToRetrySendAfter { + // this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet. + return false } if inProgress.retryCount >= maxMessageSendRetries { pathEnd.log.Error("Giving up on sending client ICQ message after max retries", @@ -745,9 +852,7 @@ func (pathEnd *pathEndRuntime) shouldSendClientICQMessage(message provider.Clien // giving up on this query // remove all retention of this client interchain query flow in pathEnd.messagesCache.ClientICQ pathEnd.messageCache.ClientICQ.DeleteMessages(queryID) - - // delete in progress query for this specific ID - delete(pathEnd.clientICQProcessing, queryID) + pathEnd.clientICQProcessing.deleteMessages(queryID) return false } @@ -779,18 +884,16 @@ func (pathEnd *pathEndRuntime) trackProcessingMessage(tracker messageToTrack) ui } channelProcessingCache, ok := msgProcessCache[eventType] if !ok { - channelProcessingCache = make(packetMessageSendCache) + channelProcessingCache = newPacketMessageSendCache() msgProcessCache[eventType] = channelProcessingCache } - if inProgress, ok := channelProcessingCache[sequence]; ok { - retryCount = inProgress.retryCount + 1 - } + inProgress := channelProcessingCache.get(sequence) - channelProcessingCache[sequence] = processingMessage{ - lastProcessedHeight: pathEnd.latestBlock.Height, - retryCount: retryCount, - assembled: t.assembled != nil, + if inProgress == nil { + channelProcessingCache.set(sequence, pathEnd.latestBlock.Height, t.assembled != nil) + } else { + inProgress.setProcessing(t.assembled != nil, inProgress.retryCount+1) } case channelMessageToTrack: eventType := t.msg.eventType @@ -800,18 +903,15 @@ func (pathEnd *pathEndRuntime) trackProcessingMessage(tracker messageToTrack) ui } msgProcessCache, ok := pathEnd.channelProcessing[eventType] if !ok { - msgProcessCache = make(channelKeySendCache) + msgProcessCache = newChannelKeySendCache() pathEnd.channelProcessing[eventType] = msgProcessCache } - if inProgress, ok := msgProcessCache[channelKey]; ok { - retryCount = inProgress.retryCount + 1 - } - - msgProcessCache[channelKey] = processingMessage{ - lastProcessedHeight: pathEnd.latestBlock.Height, - retryCount: retryCount, - assembled: t.assembled != nil, + inProgress := msgProcessCache.get(channelKey) + if inProgress == nil { + msgProcessCache.set(channelKey, pathEnd.latestBlock.Height, t.assembled != nil) + } else { + inProgress.setProcessing(t.assembled != nil, inProgress.retryCount+1) } case connectionMessageToTrack: eventType := t.msg.eventType @@ -821,36 +921,92 @@ func (pathEnd *pathEndRuntime) trackProcessingMessage(tracker messageToTrack) ui } msgProcessCache, ok := pathEnd.connProcessing[eventType] if !ok { - msgProcessCache = make(connectionKeySendCache) + msgProcessCache = newConnectionKeySendCache() pathEnd.connProcessing[eventType] = msgProcessCache } - if inProgress, ok := msgProcessCache[connectionKey]; ok { - retryCount = inProgress.retryCount + 1 - } - - msgProcessCache[connectionKey] = processingMessage{ - lastProcessedHeight: pathEnd.latestBlock.Height, - retryCount: retryCount, - assembled: t.assembled != nil, + inProgress := msgProcessCache.get(connectionKey) + if inProgress == nil { + msgProcessCache.set(connectionKey, pathEnd.latestBlock.Height, t.assembled != nil) + } else { + inProgress.setProcessing(t.assembled != nil, inProgress.retryCount+1) } case clientICQMessageToTrack: queryID := t.msg.info.QueryID - if inProgress, ok := pathEnd.clientICQProcessing[queryID]; ok { - retryCount = inProgress.retryCount + 1 - } - - pathEnd.clientICQProcessing[queryID] = processingMessage{ - lastProcessedHeight: pathEnd.latestBlock.Height, - retryCount: retryCount, - assembled: t.assembled != nil, + inProgress := pathEnd.clientICQProcessing.get(queryID) + if inProgress == nil { + pathEnd.clientICQProcessing.set(queryID, pathEnd.latestBlock.Height, t.assembled != nil) + } else { + inProgress.setProcessing(t.assembled != nil, inProgress.retryCount+1) } } return retryCount } +func (pathEnd *pathEndRuntime) trackFinishedProcessingMessage(tracker messageToTrack) { + switch t := tracker.(type) { + case packetMessageToTrack: + eventType := t.msg.eventType + sequence := t.msg.info.Sequence + channelKey, err := t.msg.channelKey() + if err != nil { + return + } + msgProcessCache, ok := pathEnd.packetProcessing[channelKey] + if !ok { + return + } + channelProcessingCache, ok := msgProcessCache[eventType] + if !ok { + return + } + + inProgress := channelProcessingCache.get(sequence) + if inProgress != nil { + inProgress.setFinishedProcessing(pathEnd.latestBlock.Height) + } + case channelMessageToTrack: + eventType := t.msg.eventType + channelKey := ChannelInfoChannelKey(t.msg.info) + if eventType != chantypes.EventTypeChannelOpenInit { + channelKey = channelKey.Counterparty() + } + msgProcessCache, ok := pathEnd.channelProcessing[eventType] + if !ok { + return + } + + inProgress := msgProcessCache.get(channelKey) + if inProgress != nil { + inProgress.setFinishedProcessing(pathEnd.latestBlock.Height) + } + case connectionMessageToTrack: + eventType := t.msg.eventType + connectionKey := ConnectionInfoConnectionKey(t.msg.info) + if eventType != conntypes.EventTypeConnectionOpenInit { + connectionKey = connectionKey.Counterparty() + } + msgProcessCache, ok := pathEnd.connProcessing[eventType] + if !ok { + return + } + + inProgress := msgProcessCache.get(connectionKey) + if inProgress != nil { + inProgress.setFinishedProcessing(pathEnd.latestBlock.Height) + } + case clientICQMessageToTrack: + queryID := t.msg.info.QueryID + + inProgress := pathEnd.clientICQProcessing.get(queryID) + if inProgress != nil { + inProgress.setFinishedProcessing(pathEnd.latestBlock.Height) + } + } +} + func (pathEnd *pathEndRuntime) localhostSentinelProofPacket( _ context.Context, _ provider.PacketInfo, @@ -874,3 +1030,44 @@ func (pathEnd *pathEndRuntime) localhostSentinelProofChannel( Version: info.Version, }, nil } + +// ShouldRelayChannel determines whether a chain channel (and optionally a port), should be relayed +// by this path end. +// +// It first checks if the channel matches any rule in the path end's filter list. If the channel matches a channel +// in an allowed list, it returns true. If the channel matches any blocked channel it returns false. Otherwise, it returns true. +// +// If no filter rule matches, it checks if the channel or its counterparty is present in the path end's +// channel state cache. This cache only holds channels relevant to the client for this path end, ensuring +// the channel belongs to a client connected to this path end. +// +// Note that this function only determines whether the channel should be relayed based on the path end's +// configuration. It does not guarantee that the channel is actually relayable, as other checks +// (e.g., expired client) may still be necessary. +func (pathEnd *pathEndRuntime) ShouldRelayChannel(chainChannelKey ChainChannelKey) bool { + pe := pathEnd.info + if pe.Rule == RuleAllowList { + for _, allowedChannel := range pe.FilterList { + if pe.shouldRelayChannelSingle(chainChannelKey, allowedChannel, true) { + return true + } + } + return false + } else if pe.Rule == RuleDenyList { + for _, blockedChannel := range pe.FilterList { + if !pe.shouldRelayChannelSingle(chainChannelKey, blockedChannel, false) { + return false + } + } + return true + } + + pathEnd.channelStateCacheMu.RLock() + defer pathEnd.channelStateCacheMu.RUnlock() + + // if no filter rule, check if the channel or counterparty channel is in the channelStateCache. + // Because channelStateCache only holds channels relevant to the client, we can ensure that the + // channel is built on top of a client for this pathEnd + _, exists := pathEnd.channelStateCache[chainChannelKey.ChannelKey] + return exists +} diff --git a/relayer/processor/path_end_test.go b/relayer/processor/path_end_test.go index 1833640f8..c0a133463 100644 --- a/relayer/processor/path_end_test.go +++ b/relayer/processor/path_end_test.go @@ -1,244 +1,307 @@ -package processor_test +package processor import ( "testing" - "github.com/cosmos/relayer/v2/relayer/processor" "github.com/stretchr/testify/require" ) const ( - testChain0 = "test-chain-0" + testChainID0 = "test-chain-0" + testChainID1 = "test-chain-1" + testChannel0 = "test-channel-0" - testPort0 = "test-port-0" testChannel1 = "test-channel-1" - testPort1 = "test-port-1" + testChannel2 = "test-channel-2" + + testPort = "trasnfer" + testPort2 = "ica-XXX" ) -// empty allow list and block list should relay everything -func TestAllowAllChannels(t *testing.T) { - mockPathEnd := processor.PathEnd{} +func TestNoChannelFilter(t *testing.T) { + mockPathEnd := PathEnd{} - mockAllowedChannel := processor.ChainChannelKey{ - ChannelKey: processor.ChannelKey{ + mockChannel := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ ChannelID: testChannel0, - PortID: testPort0, }, } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel), "does not allow channel to be relayed, even though allow list and block list are empty") - // test counterparty - mockAllowedChannel2 := processor.ChainChannelKey{ - ChannelKey: processor.ChannelKey{ - CounterpartyChannelID: testChannel1, - CounterpartyPortID: testPort1, + mockCounterpartyChannel := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ + CounterpartyChannelID: testChannel0, }, } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel2), "does not allow counterparty channel to be relayed, even though allow list and block list are empty") -} -func TestAllowAllPortsForChannel(t *testing.T) { - mockAllowList := []processor.ChainChannelKey{{ - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ChannelID: testChannel0}, - }} - mockPathEnd := processor.PathEnd{ - Rule: processor.RuleAllowList, - FilterList: mockAllowList, + mockPathEndRuntime := pathEndRuntime{ + info: mockPathEnd, + + channelStateCache: ChannelStateCache{ + mockChannel.ChannelKey: ChannelState{Open: true}, + mockCounterpartyChannel.ChannelKey: ChannelState{Open: true}, + }, + } + + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockChannel), "does not allow channel to be relayed, even though there is no filter and channel is cached") + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockCounterpartyChannel), "does not allow counterparty channel to be relayed, even though there is no filter and channel is cached") + + // channel or counterparty channel is not not included in channelStateCache, + // ie, this channel does not pertain to a both a src and dest chain in the path section of the config + // this channel is from a different client + mockChannel2 := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ + ChannelID: testChannel2, + }, } - mockAllowedChannel := processor.ChainChannelKey{ - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ + mockCounterpartyChanne2 := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ + CounterpartyChannelID: testChannel2, + }, + } + + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockChannel2), "allowed channel to be relayed, even though it was outside of cached state; this channel does not pertain to a src or dest chain in the path secion of the config") + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockCounterpartyChanne2), "allowed channel to be relayed, even though it was outside of cached state; this channel does not pertain to a src or dest chain in the path secion of the config") + +} + +func TestAllowChannelFilter(t *testing.T) { + mockAllowedChannel := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ ChannelID: testChannel0, - PortID: testPort0, }, } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel), "does not allow channel to be relayed, even though channelID is in allow list") - // test counterparty - mockAllowedChannel2 := processor.ChainChannelKey{ - CounterpartyChainID: testChain0, - ChannelKey: processor.ChannelKey{ + mockAllowedCounterPartyChannel := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ CounterpartyChannelID: testChannel0, - CounterpartyPortID: testPort0, }, } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel2), "does not allow counterparty channel to be relayed, even though channelID is in allow list") - mockBlockedChannel := processor.ChainChannelKey{ - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ - ChannelID: testChannel1, - PortID: testPort1, + // above two channels without port added to allow filter + // we should relay on any port for the channel + mockPathEnd := PathEnd{ + Rule: RuleAllowList, + FilterList: []ChainChannelKey{ + mockAllowedChannel, }, } - require.False(t, mockPathEnd.ShouldRelayChannel(mockBlockedChannel), "allows channel to be relayed, even though channelID is not in allow list") - mockBlockedChannel2 := processor.ChainChannelKey{ - CounterpartyChainID: testChain0, - ChannelKey: processor.ChannelKey{ - CounterpartyChannelID: testChannel1, - CounterpartyPortID: testPort1, + // same channel and counterparty channel as above except has designated port + // need to add these to the channelStateCache + // these should still be allowed to relay b/c the channels added to the allowlist + // didn't include a port + mockAllowedChannelWithSpecificPort := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ + ChannelID: testChannel0, + PortID: testPort, + }, + } + mockCounterPartyChannelWithSpecificPort := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ + CounterpartyChannelID: testChannel0, + CounterpartyPortID: testPort, }, } - require.False(t, mockPathEnd.ShouldRelayChannel(mockBlockedChannel2), "allows channel to be relayed, even though channelID is not in allow list") -} -func TestAllowSpecificPortForChannel(t *testing.T) { - mockAllowList := []processor.ChainChannelKey{ - { - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ - ChannelID: testChannel0, - PortID: testPort0, - }, + // channel and counterparty channel not on allow list + mockNotAllowedChannel := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ + ChannelID: testChannel2, }, } - mockPathEnd := processor.PathEnd{ - Rule: processor.RuleAllowList, - FilterList: mockAllowList, + mockNotAllowedCounterpartyChannel := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ + CounterpartyChannelID: testChannel2, + }, } - mockAllowedChannel := processor.ChainChannelKey{ - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ + mockPathEndRuntime := pathEndRuntime{info: mockPathEnd} + + // allowed channels, no port + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockAllowedChannel), "does not allow channel to be relayed, even though channelID is in allow list") + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockAllowedCounterPartyChannel), "does not allow counterparty channel to be relayed, even though channelID is in allow list") + + // allowed channels with port + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockAllowedChannelWithSpecificPort), "does not allow channel with specified port to be relayed, even though there is no port in the allow filter") + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockCounterPartyChannelWithSpecificPort), "does not allow counterparty channel with specified port to be relayed, even though there is no port in the allow filter") + + // channels not included in allow list + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockNotAllowedChannel), "allows channel to be relayed, even though channelID is not in allow list") + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockNotAllowedCounterpartyChannel), "allows channel to be relayed, even though channelID is not in allow list") +} + +func TestDenyChannelFilter(t *testing.T) { + mockBlocked := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ ChannelID: testChannel0, - PortID: testPort0, }, } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel), "does not allow channel to be relayed, even though channelID is in allow list") - // test counterparty - mockAllowedChannel2 := processor.ChainChannelKey{ - CounterpartyChainID: testChain0, - ChannelKey: processor.ChannelKey{ + mockBlockedCounterparty := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ CounterpartyChannelID: testChannel0, - CounterpartyPortID: testPort0, }, } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel2), "does not allow counterparty channel to be relayed, even though channelID is in allow list") - mockBlockedChannel := processor.ChainChannelKey{ - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ - ChannelID: testChannel0, - PortID: testPort1, + // blocked channels added to deny list + mockPathEnd := PathEnd{ + Rule: RuleDenyList, + FilterList: []ChainChannelKey{ + mockBlocked, }, } - require.False(t, mockPathEnd.ShouldRelayChannel(mockBlockedChannel), "allows channel to be relayed, even though portID is not in allow list") - mockBlockedChannel2 := processor.ChainChannelKey{ - CounterpartyChainID: testChain0, - ChannelKey: processor.ChannelKey{ + // same channel and counterparty channel as above except has designated port + // need to add these to the channelStateCache + // these should not allowed to relay b/c the channels were added to the denylist + mockBlockedChannelWithSpecificPort := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ + ChannelID: testChannel0, + PortID: testPort, + }, + } + mockBlockedCounterPartyChannelWithSpecificPort := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ CounterpartyChannelID: testChannel0, - CounterpartyPortID: testPort1, + CounterpartyPortID: testPort, }, } - require.False(t, mockPathEnd.ShouldRelayChannel(mockBlockedChannel2), "allows channel to be relayed, even though portID is not in allow list") -} -func TestBlockAllPortsForChannel(t *testing.T) { - mockBlockList := []processor.ChainChannelKey{ - { - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ - ChannelID: testChannel0, - }, + // channel and counterparty channel not added to deny list + mockNotBlocked := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ + ChannelID: testChannel2, }, } - mockPathEnd := processor.PathEnd{ - Rule: processor.RuleDenyList, - FilterList: mockBlockList, + + mockNotBlockedCounterparty := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ + CounterpartyChannelID: testChannel2, + }, } - mockBlockedChannel := processor.ChainChannelKey{ - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ + mockPathEndRuntime := pathEndRuntime{info: mockPathEnd} + + // channels added to deny list + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockBlocked), "allows channel to be relayed, even though channelID is in deny list") + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockBlockedCounterparty), "allows channel to be relayed, even though channelID is in deny list") + + // channels added to deny list with specific port + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockBlockedChannelWithSpecificPort), "allows channel to be relayed, even though channel is in deny list") + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockBlockedCounterPartyChannelWithSpecificPort), "allows channel to be relayed, even though channel is in deny list") + + // channels not included in deny list + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockNotBlocked), "does not allow channel to be relayed, even though channelID is not in deny list") + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockNotBlockedCounterparty), "does not allow channel to be relayed, even though channelID is not in deny list") + +} + +func TestAllowChannelFilterWithSpecificPort(t *testing.T) { + mockAllowedChannelWithPort := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ ChannelID: testChannel0, - PortID: testPort0, + PortID: testPort, }, } - require.False(t, mockPathEnd.ShouldRelayChannel(mockBlockedChannel), "allows channel to be relayed, even though channelID is in block list") - // test counterparty - mockBlockedChannel2 := processor.ChainChannelKey{ - CounterpartyChainID: testChain0, - ChannelKey: processor.ChannelKey{ + mockAllowedCounterpartyWithPort := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ CounterpartyChannelID: testChannel0, - CounterpartyPortID: testPort0, + CounterpartyPortID: testPort, }, } - require.False(t, mockPathEnd.ShouldRelayChannel(mockBlockedChannel2), "allows counterparty channel to be relayed, even though channelID is in block list") - mockAllowedChannel := processor.ChainChannelKey{ - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ - ChannelID: testChannel1, - PortID: testPort1, + mockPathEnd := PathEnd{ + Rule: RuleAllowList, + FilterList: []ChainChannelKey{ + mockAllowedChannelWithPort, }, } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel), "does not allow channel to be relayed, even though channelID is not in block list") - mockAllowedChannel2 := processor.ChainChannelKey{ - CounterpartyChainID: testChain0, - ChannelKey: processor.ChannelKey{ - CounterpartyChannelID: testChannel1, - CounterpartyPortID: testPort1, - }, - } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel2), "does not allow counterparty channel to be relayed, even though channelID is not in block list") -} + mockPathEndRuntime := pathEndRuntime{info: mockPathEnd} + + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockAllowedChannelWithPort), "does not allow port to be relayed on, even though portID is in allow list") + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockAllowedCounterpartyWithPort), "does not allow port to be relayed on, even though portID is in allow list") -func TestBlockSpecificPortForChannel(t *testing.T) { - mockBlockList := []processor.ChainChannelKey{ - { - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ - ChannelID: testChannel0, - PortID: testPort0, - }, + // same channel without designated port + mockAllowedChannelWithOutPort := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ + ChannelID: testChannel0, }, } - mockPathEnd := processor.PathEnd{ - Rule: processor.RuleDenyList, - FilterList: mockBlockList, - } - mockBlockedChannel := processor.ChainChannelKey{ - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockAllowedChannelWithOutPort), "allows port to be relayed on, even though portID is not in allow list") +} + +func TestDenyChannelWithSpecificPort(t *testing.T) { + mockDeniedChannelWithPort := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ ChannelID: testChannel0, - PortID: testPort0, + PortID: testPort, }, } - require.False(t, mockPathEnd.ShouldRelayChannel(mockBlockedChannel), "allows channel to be relayed, even though channelID/portID is in block list") - // test counterparty - mockBlockedChannel2 := processor.ChainChannelKey{ - CounterpartyChainID: testChain0, - ChannelKey: processor.ChannelKey{ + mockCounterpartyDeniedChannelWithPort := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ CounterpartyChannelID: testChannel0, - CounterpartyPortID: testPort0, + CounterpartyPortID: testPort, }, } - require.False(t, mockPathEnd.ShouldRelayChannel(mockBlockedChannel2), "allows counterparty channel to be relayed, even though channelID/portID is in block list") - mockAllowedChannel := processor.ChainChannelKey{ - ChainID: testChain0, - ChannelKey: processor.ChannelKey{ + // same path with different port + mockChannelWithAllowedPort := ChainChannelKey{ + ChainID: testChainID0, + ChannelKey: ChannelKey{ ChannelID: testChannel0, - PortID: testPort1, + PortID: testPort2, }, } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel), "does not allow channel to be relayed, even though portID is not in block list") - mockAllowedChannel2 := processor.ChainChannelKey{ - CounterpartyChainID: testChain0, - ChannelKey: processor.ChannelKey{ + mocCounterpartykChannelWithAllowedPort := ChainChannelKey{ + CounterpartyChainID: testChainID0, + ChannelKey: ChannelKey{ CounterpartyChannelID: testChannel0, - CounterpartyPortID: testPort1, + CounterpartyPortID: testPort2, }, } - require.True(t, mockPathEnd.ShouldRelayChannel(mockAllowedChannel2), "does not allow counterparty channel to be relayed, even though portID is not in block list") + + mockPathEnd := PathEnd{ + Rule: RuleDenyList, + FilterList: []ChainChannelKey{ + mockDeniedChannelWithPort, + }, + } + + mockPathEndRuntime := pathEndRuntime{info: mockPathEnd} + + // channels and ports added to deny list + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockDeniedChannelWithPort), "allows port to be relayed on, even though portID is in deny list") + require.False(t, mockPathEndRuntime.ShouldRelayChannel(mockCounterpartyDeniedChannelWithPort), "allows port to be relayed on, even though portID is in deny list") + + // same channels with different ports + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mockChannelWithAllowedPort), "does not allow port to be relayed on, even though portID is not in deny list") + require.True(t, mockPathEndRuntime.ShouldRelayChannel(mocCounterpartykChannelWithAllowedPort), "does not allow port to be relayed on, even though portID is not in deny list") + } diff --git a/relayer/processor/path_processor.go b/relayer/processor/path_processor.go index 5b0b2c76e..b8b9d4da2 100644 --- a/relayer/processor/path_processor.go +++ b/relayer/processor/path_processor.go @@ -5,8 +5,8 @@ import ( "fmt" "time" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" ) @@ -32,11 +32,6 @@ const ( // Amount of time between flushes if the previous flush failed. flushFailureRetry = 5 * time.Second - // If message assembly fails from either proof query failure on the source - // or assembling the message for the destination, how many blocks should pass - // before retrying. - blocksToRetryAssemblyAfter = 0 - // If the message was assembled successfully, but sending the message failed, // how many blocks should pass before retrying. blocksToRetrySendAfter = 5 @@ -79,7 +74,8 @@ type PathProcessor struct { // true if this is a localhost IBC connection isLocalhost bool - maxMsgs uint64 + maxMsgs uint64 + memoLimit, maxReceiverSize int metrics *PrometheusMetrics } @@ -105,6 +101,7 @@ func NewPathProcessor( clientUpdateThresholdTime time.Duration, flushInterval time.Duration, maxMsgs uint64, + memoLimit, maxReceiverSize int, ) *PathProcessor { isLocalhost := pathEnd1.ClientID == ibcexported.LocalhostClientID @@ -119,6 +116,8 @@ func NewPathProcessor( metrics: metrics, isLocalhost: isLocalhost, maxMsgs: maxMsgs, + memoLimit: memoLimit, + maxReceiverSize: maxReceiverSize, } if flushInterval == 0 { pp.disablePeriodicFlush() @@ -233,9 +232,9 @@ func (pp *PathProcessor) SetChainProviderIfApplicable(chainProvider provider.Cha func (pp *PathProcessor) IsRelayedChannel(chainID string, channelKey ChannelKey) bool { if pp.pathEnd1.info.ChainID == chainID { - return pp.pathEnd1.info.ShouldRelayChannel(ChainChannelKey{ChainID: chainID, CounterpartyChainID: pp.pathEnd2.info.ChainID, ChannelKey: channelKey}) + return pp.pathEnd1.ShouldRelayChannel(ChainChannelKey{ChainID: chainID, CounterpartyChainID: pp.pathEnd2.info.ChainID, ChannelKey: channelKey}) } else if pp.pathEnd2.info.ChainID == chainID { - return pp.pathEnd2.info.ShouldRelayChannel(ChainChannelKey{ChainID: chainID, CounterpartyChainID: pp.pathEnd1.info.ChainID, ChannelKey: channelKey}) + return pp.pathEnd2.ShouldRelayChannel(ChainChannelKey{ChainID: chainID, CounterpartyChainID: pp.pathEnd1.info.ChainID, ChannelKey: channelKey}) } return false } @@ -317,17 +316,71 @@ func (pp *PathProcessor) processAvailableSignals(ctx context.Context, cancel fun zap.Error(ctx.Err()), ) return true + case t := <-pp.pathEnd1.finishedProcessing: + pp.pathEnd1.trackFinishedProcessingMessage(t) + case t := <-pp.pathEnd2.finishedProcessing: + pp.pathEnd2.trackFinishedProcessingMessage(t) case d := <-pp.pathEnd1.incomingCacheData: // we have new data from ChainProcessor for pathEnd1 - pp.pathEnd1.mergeCacheData(ctx, cancel, d, pp.pathEnd2.info.ChainID, pp.pathEnd2.inSync, pp.messageLifecycle, pp.pathEnd2) + pp.pathEnd1.mergeCacheData( + ctx, + cancel, + d, + pp.pathEnd2.info.ChainID, + pp.pathEnd2.inSync, + pp.messageLifecycle, + pp.pathEnd2, + pp.memoLimit, + pp.maxReceiverSize, + ) case d := <-pp.pathEnd2.incomingCacheData: // we have new data from ChainProcessor for pathEnd2 - pp.pathEnd2.mergeCacheData(ctx, cancel, d, pp.pathEnd1.info.ChainID, pp.pathEnd1.inSync, pp.messageLifecycle, pp.pathEnd1) + pp.pathEnd2.mergeCacheData( + ctx, + cancel, + d, + pp.pathEnd1.info.ChainID, + pp.pathEnd1.inSync, + pp.messageLifecycle, + pp.pathEnd1, + pp.memoLimit, + pp.maxReceiverSize, + ) case <-pp.retryProcess: // No new data to merge in, just retry handling. case <-pp.flushTimer.C: + for len(pp.pathEnd1.incomingCacheData) > 0 { + d := <-pp.pathEnd1.incomingCacheData + // we have new data from ChainProcessor for pathEnd1 + pp.pathEnd1.mergeCacheData( + ctx, + cancel, + d, + pp.pathEnd2.info.ChainID, + pp.pathEnd2.inSync, + pp.messageLifecycle, + pp.pathEnd2, + pp.memoLimit, + pp.maxReceiverSize, + ) + } + for len(pp.pathEnd2.incomingCacheData) > 0 { + d := <-pp.pathEnd2.incomingCacheData + // we have new data from ChainProcessor for pathEnd2 + pp.pathEnd2.mergeCacheData( + ctx, + cancel, + d, + pp.pathEnd1.info.ChainID, + pp.pathEnd1.inSync, + pp.messageLifecycle, + pp.pathEnd1, + pp.memoLimit, + pp.maxReceiverSize, + ) + } // Periodic flush to clear out any old packets pp.handleFlush(ctx) } @@ -346,7 +399,7 @@ func (pp *PathProcessor) Run(ctx context.Context, cancel func()) { return } - for len(pp.pathEnd1.incomingCacheData) > 0 || len(pp.pathEnd2.incomingCacheData) > 0 || len(pp.retryProcess) > 0 { + for len(pp.pathEnd1.incomingCacheData) > 0 || len(pp.pathEnd2.incomingCacheData) > 0 || len(pp.retryProcess) > 0 || len(pp.pathEnd1.finishedProcessing) > 0 || len(pp.pathEnd2.finishedProcessing) > 0 { // signals are available, so this will not need to block. if pp.processAvailableSignals(ctx, cancel) { return diff --git a/relayer/processor/path_processor_internal.go b/relayer/processor/path_processor_internal.go index 58bbcc4a5..b78c579b1 100644 --- a/relayer/processor/path_processor_internal.go +++ b/relayer/processor/path_processor_internal.go @@ -8,8 +8,8 @@ import ( "sort" "sync" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" "golang.org/x/sync/errgroup" @@ -233,16 +233,6 @@ func (pp *PathProcessor) unrelayedPacketFlowMessages( toDeleteSrc[chantypes.EventTypeAcknowledgePacket] = append(toDeleteSrc[chantypes.EventTypeAcknowledgePacket], seq) } - for seq, info := range pathEndPacketFlowMessages.SrcMsgTimeoutOnClose { - // we have observed a timeout-on-close on chain for this packet, so packet flow is complete - // remove all retention of this sequence number - deletePreInitIfMatches(info) - toDeleteSrc[chantypes.EventTypeSendPacket] = append(toDeleteSrc[chantypes.EventTypeSendPacket], seq) - toDeleteDst[chantypes.EventTypeRecvPacket] = append(toDeleteDst[chantypes.EventTypeRecvPacket], seq) - toDeleteDst[chantypes.EventTypeWriteAck] = append(toDeleteDst[chantypes.EventTypeWriteAck], seq) - toDeleteSrc[chantypes.EventTypeAcknowledgePacket] = append(toDeleteSrc[chantypes.EventTypeAcknowledgePacket], seq) - } - for seq, info := range pathEndPacketFlowMessages.SrcMsgTimeout { deletePreInitIfMatches(info) toDeleteSrc[chantypes.EventTypeSendPacket] = append(toDeleteSrc[chantypes.EventTypeSendPacket], seq) @@ -291,7 +281,6 @@ func (pp *PathProcessor) unrelayedPacketFlowMessages( if err := pathEndPacketFlowMessages.Dst.chainProvider.ValidatePacket(info, pathEndPacketFlowMessages.Dst.latestBlock); err != nil { var timeoutHeightErr *provider.TimeoutHeightError var timeoutTimestampErr *provider.TimeoutTimestampError - var timeoutOnCloseErr *provider.TimeoutOnCloseError switch { case errors.As(err, &timeoutHeightErr) || errors.As(err, &timeoutTimestampErr): @@ -300,12 +289,6 @@ func (pp *PathProcessor) unrelayedPacketFlowMessages( info: info, } msgs = append(msgs, timeoutMsg) - case errors.As(err, &timeoutOnCloseErr): - timeoutOnCloseMsg := packetIBCMessage{ - eventType: chantypes.EventTypeTimeoutPacketOnClose, - info: info, - } - msgs = append(msgs, timeoutOnCloseMsg) default: pp.log.Error("Packet is invalid", zap.String("chain_id", pathEndPacketFlowMessages.Src.info.ChainID), @@ -645,6 +628,10 @@ func (pp *PathProcessor) unrelayedChannelCloseMessages( msgCloseConfirm, pathEndChannelCloseMessages.Src, ) { res.DstMessages = append(res.DstMessages, msgCloseConfirm) + toDeleteSrc[chantypes.EventTypeChannelCloseInit] = append( + toDeleteSrc[chantypes.EventTypeChannelCloseInit], + chanKey, + ) } // TODO: confirm chankey does not need modification @@ -670,13 +657,14 @@ func (pp *PathProcessor) unrelayedChannelCloseMessages( } func (pp *PathProcessor) getUnrelayedClientICQMessages(pathEnd *pathEndRuntime, queryMessages, responseMessages ClientICQMessageCache) (res []clientICQMessage) { + var doneQueryIDs []provider.ClientICQQueryID + ClientICQLoop: for queryID, queryMsg := range queryMessages { for resQueryID := range responseMessages { if queryID == resQueryID { // done with this query, remove all retention. - pathEnd.messageCache.ClientICQ.DeleteMessages(queryID) - delete(pathEnd.clientICQProcessing, queryID) + doneQueryIDs = append(doneQueryIDs, queryID) continue ClientICQLoop } } @@ -688,11 +676,16 @@ ClientICQLoop: } } - // now iterate through completion message and remove any leftover messages. + // remove all retention for queries that have been responded to. for queryID := range responseMessages { - pathEnd.messageCache.ClientICQ.DeleteMessages(queryID) - delete(pathEnd.clientICQProcessing, queryID) + doneQueryIDs = append(doneQueryIDs, queryID) } + + pathEnd.clientICQProcessing.deleteMessages(doneQueryIDs...) + pathEnd.messageCache.ClientICQ.DeleteMessages(doneQueryIDs...) + + // now iterate through completion message and remove any leftover messages. + return res } @@ -1002,7 +995,6 @@ func (pp *PathProcessor) processLatestMessages(ctx context.Context, cancel func( DstMsgRecvPacket: pathEnd1DstMsgRecvPacket, SrcMsgAcknowledgement: pp.pathEnd1.messageCache.PacketFlow[pair.pathEnd1ChannelKey][chantypes.EventTypeAcknowledgePacket], SrcMsgTimeout: pp.pathEnd1.messageCache.PacketFlow[pair.pathEnd1ChannelKey][chantypes.EventTypeTimeoutPacket], - SrcMsgTimeoutOnClose: pp.pathEnd1.messageCache.PacketFlow[pair.pathEnd1ChannelKey][chantypes.EventTypeTimeoutPacketOnClose], } pathEnd2PacketFlowMessages := pathEndPacketFlowMessages{ Src: pp.pathEnd2, @@ -1013,7 +1005,6 @@ func (pp *PathProcessor) processLatestMessages(ctx context.Context, cancel func( DstMsgRecvPacket: pathEnd2DstMsgRecvPacket, SrcMsgAcknowledgement: pp.pathEnd2.messageCache.PacketFlow[pair.pathEnd2ChannelKey][chantypes.EventTypeAcknowledgePacket], SrcMsgTimeout: pp.pathEnd2.messageCache.PacketFlow[pair.pathEnd2ChannelKey][chantypes.EventTypeTimeoutPacket], - SrcMsgTimeoutOnClose: pp.pathEnd2.messageCache.PacketFlow[pair.pathEnd2ChannelKey][chantypes.EventTypeTimeoutPacketOnClose], } pathEnd1ProcessRes[i] = pp.unrelayedPacketFlowMessages(ctx, pathEnd1PacketFlowMessages) @@ -1219,6 +1210,10 @@ func (pp *PathProcessor) queuePendingRecvAndAcks( if len(seqs) == 0 { src.log.Debug("Nothing to flush", zap.String("channel", k.ChannelID), zap.String("port", k.PortID)) + if pp.metrics != nil { + pp.metrics.SetUnrelayedPackets(pp.pathEnd1.info.PathName, src.info.ChainID, dst.info.ChainID, k.ChannelID, k.CounterpartyChannelID, 0) + pp.metrics.SetUnrelayedAcks(pp.pathEnd1.info.PathName, src.info.ChainID, dst.info.ChainID, k.ChannelID, k.CounterpartyChannelID, 0) + } return nil, nil } @@ -1229,6 +1224,10 @@ func (pp *PathProcessor) queuePendingRecvAndAcks( return nil, err } + if pp.metrics != nil { + pp.metrics.SetUnrelayedPackets(pp.pathEnd1.info.PathName, src.info.ChainID, dst.info.ChainID, k.ChannelID, k.CounterpartyChannelID, len(unrecv)) + } + dstHeight := int64(dst.latestBlock.Height) var order chantypes.Order @@ -1268,6 +1267,10 @@ func (pp *PathProcessor) queuePendingRecvAndAcks( var skipped *skippedPackets for i, seq := range unrecv { + if state, ok := dst.messageCache.PacketState.State(k, seq); ok && stateValue(state) >= stateValue(chantypes.EventTypeRecvPacket) { + continue // already recv'd by path processor + } + srcMu.Lock() if srcCache.IsCached(chantypes.EventTypeSendPacket, k, seq) { continue // already cached @@ -1342,9 +1345,18 @@ SeqLoop: unacked = append(unacked, seq) } + if pp.metrics != nil { + pp.metrics.SetUnrelayedAcks(pp.pathEnd1.info.PathName, src.info.ChainID, dst.info.ChainID, k.ChannelID, k.CounterpartyChannelID, len(unacked)) + } + for i, seq := range unacked { - dstMu.Lock() ck := k.Counterparty() + + if state, ok := dst.messageCache.PacketState.State(ck, seq); ok && stateValue(state) >= stateValue(chantypes.EventTypeAcknowledgePacket) { + continue // already acked by path processor + } + + dstMu.Lock() if dstCache.IsCached(chantypes.EventTypeRecvPacket, ck, seq) && dstCache.IsCached(chantypes.EventTypeWriteAck, ck, seq) { continue // already cached @@ -1424,7 +1436,7 @@ func (pp *PathProcessor) flush(ctx context.Context) error { if !cs.Open { continue } - if !pp.pathEnd1.info.ShouldRelayChannel(ChainChannelKey{ + if !pp.pathEnd1.ShouldRelayChannel(ChainChannelKey{ ChainID: pp.pathEnd1.info.ChainID, CounterpartyChainID: pp.pathEnd2.info.ChainID, ChannelKey: k, @@ -1437,7 +1449,7 @@ func (pp *PathProcessor) flush(ctx context.Context) error { if !cs.Open { continue } - if !pp.pathEnd2.info.ShouldRelayChannel(ChainChannelKey{ + if !pp.pathEnd2.ShouldRelayChannel(ChainChannelKey{ ChainID: pp.pathEnd2.info.ChainID, CounterpartyChainID: pp.pathEnd1.info.ChainID, ChannelKey: k, @@ -1477,17 +1489,32 @@ func (pp *PathProcessor) flush(ctx context.Context) error { for k, seqs := range commitments2 { k := k seqs := seqs + eg.Go(func() error { - s, err := pp.queuePendingRecvAndAcks(ctx, pp.pathEnd2, pp.pathEnd1, k, seqs, pathEnd2Cache.PacketFlow, pathEnd1Cache.PacketFlow, &pathEnd2CacheMu, &pathEnd1CacheMu) + s, err := pp.queuePendingRecvAndAcks( + ctx, + pp.pathEnd2, + pp.pathEnd1, + k, + seqs, + pathEnd2Cache.PacketFlow, + pathEnd1Cache.PacketFlow, + &pathEnd2CacheMu, + &pathEnd1CacheMu, + ) + if err != nil { return err } + if s != nil { if _, ok := skipped[pp.pathEnd2.info.ChainID]; !ok { skipped[pp.pathEnd2.info.ChainID] = make(map[ChannelKey]skippedPackets) } + skipped[pp.pathEnd2.info.ChainID][k] = *s } + return nil }) } @@ -1496,8 +1523,8 @@ func (pp *PathProcessor) flush(ctx context.Context) error { return fmt.Errorf("failed to enqueue pending messages for flush: %w", err) } - pp.pathEnd1.mergeMessageCache(pathEnd1Cache, pp.pathEnd2.info.ChainID, pp.pathEnd2.inSync) - pp.pathEnd2.mergeMessageCache(pathEnd2Cache, pp.pathEnd1.info.ChainID, pp.pathEnd1.inSync) + pp.pathEnd1.mergeMessageCache(pathEnd1Cache, pp.pathEnd2.info.ChainID, pp.pathEnd2.inSync, pp.memoLimit, pp.maxReceiverSize) + pp.pathEnd2.mergeMessageCache(pathEnd2Cache, pp.pathEnd1.info.ChainID, pp.pathEnd1.inSync, pp.memoLimit, pp.maxReceiverSize) if len(skipped) > 0 { skippedPacketsString := "" diff --git a/relayer/processor/types.go b/relayer/processor/types.go index 27b9b7f40..00286c78e 100644 --- a/relayer/processor/types.go +++ b/relayer/processor/types.go @@ -4,7 +4,7 @@ import ( "fmt" "sort" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap/zapcore" ) @@ -91,6 +91,7 @@ func (t *ChannelCloseLifecycle) messageLifecycler() {} // which will retain relevant messages for each PathProcessor. type IBCMessagesCache struct { PacketFlow ChannelPacketMessagesCache + PacketState ChannelPacketStateCache ConnectionHandshake ConnectionMessagesCache ChannelHandshake ChannelMessagesCache ClientICQ ClientICQMessagesCache @@ -115,6 +116,7 @@ func (c IBCMessagesCache) Clone() IBCMessagesCache { func NewIBCMessagesCache() IBCMessagesCache { return IBCMessagesCache{ PacketFlow: make(ChannelPacketMessagesCache), + PacketState: make(ChannelPacketStateCache), ConnectionHandshake: make(ConnectionMessagesCache), ChannelHandshake: make(ChannelMessagesCache), ClientICQ: make(ClientICQMessagesCache), @@ -124,12 +126,18 @@ func NewIBCMessagesCache() IBCMessagesCache { // ChannelPacketMessagesCache is used for caching a PacketMessagesCache for a given IBC channel. type ChannelPacketMessagesCache map[ChannelKey]PacketMessagesCache +// ChannelPacketStateCache is used for caching a PacketSequenceStateCache for a given IBC channel. +type ChannelPacketStateCache map[ChannelKey]PacketSequenceStateCache + // PacketMessagesCache is used for caching a PacketSequenceCache for a given IBC message type. type PacketMessagesCache map[string]PacketSequenceCache // PacketSequenceCache is used for caching an IBC message for a given packet sequence. type PacketSequenceCache map[uint64]provider.PacketInfo +// PacketSequenceStateCache is used for caching the state of a packet sequence. +type PacketSequenceStateCache map[uint64]string + // ChannelMessagesCache is used for caching a ChannelMessageCache for a given IBC message type. type ChannelMessagesCache map[string]ChannelMessageCache @@ -344,6 +352,76 @@ func (c PacketMessagesCache) DeleteMessages(toDelete ...map[string][]uint64) { } } +func stateValue(state string) int { + switch state { + case chantypes.EventTypeSendPacket: + return 1 + case chantypes.EventTypeRecvPacket: + return 2 + case chantypes.EventTypeWriteAck: + return 3 + case chantypes.EventTypeAcknowledgePacket, chantypes.EventTypeTimeoutPacket: + return 4 + } + panic(fmt.Errorf("unexpected state: %s", state)) +} + +func (c ChannelPacketStateCache) UpdateState(k ChannelKey, sequence uint64, state string) { + minState := 0 + if sequenceCache, ok := c[k]; ok { + if currentState, ok := sequenceCache[sequence]; ok { + minState = stateValue(currentState) + } + } else { + c[k] = make(PacketSequenceStateCache) + } + + if stateValue(state) <= minState { + // can't downgrade state + return + } + + c[k][sequence] = state +} + +func (c ChannelPacketStateCache) State(k ChannelKey, sequence uint64) (string, bool) { + sequenceCache, ok := c[k] + if !ok { + return "", false + } + + state, ok := sequenceCache[sequence] + if !ok { + return "", false + } + + return state, true +} + +// Prune deletes all map entries except for the most recent (keep) for all channels. +func (c ChannelPacketStateCache) Prune(keep int) { + for _, pssc := range c { + pssc.Prune(keep) + } +} + +// Prune deletes all map entries except for the most recent (keep). +func (c PacketSequenceStateCache) Prune(keep int) { + if len(c) <= keep { + return + } + seqs := make([]uint64, 0, len(c)) + for seq := range c { + seqs = append(seqs, seq) + } + sort.Slice(seqs, func(i, j int) bool { return seqs[i] < seqs[j] }) + + // only keep recent packet states + for _, seq := range seqs[:len(seqs)-keep] { + delete(c, seq) + } +} + // IsCached returns true if a sequence for a channel key and event type is already cached. func (c ChannelPacketMessagesCache) IsCached(eventType string, k ChannelKey, sequence uint64) bool { if _, ok := c[k]; !ok { @@ -535,9 +613,11 @@ func (c ClientICQMessageCache) Merge(other ClientICQMessageCache) { } // DeleteMessages deletes cached messages for the provided query ID. -func (c ClientICQMessagesCache) DeleteMessages(queryID provider.ClientICQQueryID) { - for _, cm := range c { - delete(cm, queryID) +func (c ClientICQMessagesCache) DeleteMessages(queryID ...provider.ClientICQQueryID) { + for _, qID := range queryID { + for _, cm := range c { + delete(cm, qID) + } } } @@ -580,7 +660,7 @@ func PacketInfoChannelKey(eventType string, info provider.PacketInfo) (ChannelKe switch eventType { case chantypes.EventTypeRecvPacket, chantypes.EventTypeWriteAck: return packetInfoChannelKey(info).Counterparty(), nil - case chantypes.EventTypeSendPacket, chantypes.EventTypeAcknowledgePacket, chantypes.EventTypeTimeoutPacket, chantypes.EventTypeTimeoutPacketOnClose: + case chantypes.EventTypeSendPacket, chantypes.EventTypeAcknowledgePacket, chantypes.EventTypeTimeoutPacket: return packetInfoChannelKey(info), nil } return ChannelKey{}, fmt.Errorf("eventType not expected for packetIBCMessage channelKey: %s", eventType) diff --git a/relayer/processor/types_internal.go b/relayer/processor/types_internal.go index d135f123c..c3079cd12 100644 --- a/relayer/processor/types_internal.go +++ b/relayer/processor/types_internal.go @@ -5,10 +5,11 @@ import ( "encoding/base64" "fmt" "strings" + "sync" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap/zapcore" ) @@ -72,14 +73,6 @@ func (msg packetIBCMessage) assemble( } assembleMessage = dst.chainProvider.MsgTimeout - case chantypes.EventTypeTimeoutPacketOnClose: - if msg.info.ChannelOrder == chantypes.ORDERED.String() { - packetProof = src.chainProvider.NextSeqRecv - } else { - packetProof = src.chainProvider.PacketReceipt - } - - assembleMessage = dst.chainProvider.MsgTimeoutOnClose default: return nil, fmt.Errorf("unexepected packet message eventType for message assembly: %s", msg.eventType) } @@ -341,52 +334,200 @@ func (msg clientICQMessage) MarshalLogObject(enc zapcore.ObjectEncoder) error { // processingMessage tracks the state of a IBC message currently being processed. type processingMessage struct { - assembled bool - lastProcessedHeight uint64 retryCount uint64 + lastProcessedHeight uint64 + assembled bool + + processing bool + mu sync.Mutex +} + +func (m *processingMessage) isProcessing() bool { + m.mu.Lock() + defer m.mu.Unlock() + return m.processing +} + +func (m *processingMessage) setProcessing(assembled bool, retryCount uint64) { + m.mu.Lock() + defer m.mu.Unlock() + m.processing = true + m.retryCount = retryCount + m.assembled = assembled +} + +func (m *processingMessage) setFinishedProcessing(height uint64) { + m.mu.Lock() + defer m.mu.Unlock() + m.lastProcessedHeight = height + m.processing = false } type packetProcessingCache map[ChannelKey]packetChannelMessageCache -type packetChannelMessageCache map[string]packetMessageSendCache -type packetMessageSendCache map[uint64]processingMessage +type packetChannelMessageCache map[string]*packetMessageSendCache + +type packetMessageSendCache struct { + mu sync.Mutex + m map[uint64]*processingMessage +} + +func newPacketMessageSendCache() *packetMessageSendCache { + return &packetMessageSendCache{ + m: make(map[uint64]*processingMessage), + } +} + +func (c *packetMessageSendCache) get(sequence uint64) *processingMessage { + c.mu.Lock() + defer c.mu.Unlock() + return c.m[sequence] +} + +func (c *packetMessageSendCache) set(sequence uint64, height uint64, assembled bool) { + c.mu.Lock() + defer c.mu.Unlock() + c.m[sequence] = &processingMessage{ + processing: true, + lastProcessedHeight: height, + assembled: assembled, + } +} func (c packetChannelMessageCache) deleteMessages(toDelete ...map[string][]uint64) { for _, toDeleteMap := range toDelete { for message, toDeleteMessages := range toDeleteMap { + if _, ok := c[message]; !ok { + continue + } + c[message].mu.Lock() for _, sequence := range toDeleteMessages { - delete(c[message], sequence) + delete(c[message].m, sequence) } + c[message].mu.Unlock() } } } -type channelProcessingCache map[string]channelKeySendCache -type channelKeySendCache map[ChannelKey]processingMessage +type channelProcessingCache map[string]*channelKeySendCache +type channelKeySendCache struct { + mu sync.Mutex + m map[ChannelKey]*processingMessage +} + +func newChannelKeySendCache() *channelKeySendCache { + return &channelKeySendCache{ + m: make(map[ChannelKey]*processingMessage), + } +} + +func (c *channelKeySendCache) get(key ChannelKey) *processingMessage { + c.mu.Lock() + defer c.mu.Unlock() + return c.m[key] +} + +func (c *channelKeySendCache) set(key ChannelKey, height uint64, assembled bool) { + c.mu.Lock() + defer c.mu.Unlock() + c.m[key] = &processingMessage{ + processing: true, + lastProcessedHeight: height, + assembled: assembled, + } +} func (c channelProcessingCache) deleteMessages(toDelete ...map[string][]ChannelKey) { for _, toDeleteMap := range toDelete { for message, toDeleteMessages := range toDeleteMap { + if _, ok := c[message]; !ok { + continue + } + c[message].mu.Lock() for _, channel := range toDeleteMessages { - delete(c[message], channel) + delete(c[message].m, channel) } + c[message].mu.Unlock() } } } -type connectionProcessingCache map[string]connectionKeySendCache -type connectionKeySendCache map[ConnectionKey]processingMessage +type connectionProcessingCache map[string]*connectionKeySendCache +type connectionKeySendCache struct { + mu sync.Mutex + m map[ConnectionKey]*processingMessage +} + +func newConnectionKeySendCache() *connectionKeySendCache { + return &connectionKeySendCache{ + m: make(map[ConnectionKey]*processingMessage), + } +} + +func (c *connectionKeySendCache) get(key ConnectionKey) *processingMessage { + c.mu.Lock() + defer c.mu.Unlock() + return c.m[key] +} + +func (c *connectionKeySendCache) set(key ConnectionKey, height uint64, assembled bool) { + c.mu.Lock() + defer c.mu.Unlock() + c.m[key] = &processingMessage{ + processing: true, + lastProcessedHeight: height, + assembled: assembled, + } +} func (c connectionProcessingCache) deleteMessages(toDelete ...map[string][]ConnectionKey) { for _, toDeleteMap := range toDelete { for message, toDeleteMessages := range toDeleteMap { + if _, ok := c[message]; !ok { + continue + } + c[message].mu.Lock() for _, connection := range toDeleteMessages { - delete(c[message], connection) + delete(c[message].m, connection) } + c[message].mu.Unlock() } } } -type clientICQProcessingCache map[provider.ClientICQQueryID]processingMessage +type clientICQProcessingCache struct { + mu sync.Mutex + m map[provider.ClientICQQueryID]*processingMessage +} + +func newClientICQProcessingCache() *clientICQProcessingCache { + return &clientICQProcessingCache{ + m: make(map[provider.ClientICQQueryID]*processingMessage), + } +} + +func (c *clientICQProcessingCache) get(queryID provider.ClientICQQueryID) *processingMessage { + c.mu.Lock() + defer c.mu.Unlock() + return c.m[queryID] +} + +func (c *clientICQProcessingCache) set(queryID provider.ClientICQQueryID, height uint64, assembled bool) { + c.mu.Lock() + defer c.mu.Unlock() + c.m[queryID] = &processingMessage{ + processing: true, + lastProcessedHeight: height, + assembled: assembled, + } +} + +func (c *clientICQProcessingCache) deleteMessages(toDelete ...provider.ClientICQQueryID) { + c.mu.Lock() + defer c.mu.Unlock() + for _, queryID := range toDelete { + delete(c.m, queryID) + } +} // contains MsgRecvPacket from counterparty // entire packet flow @@ -399,7 +540,6 @@ type pathEndPacketFlowMessages struct { DstMsgRecvPacket PacketSequenceCache SrcMsgAcknowledgement PacketSequenceCache SrcMsgTimeout PacketSequenceCache - SrcMsgTimeoutOnClose PacketSequenceCache } type pathEndConnectionHandshakeMessages struct { diff --git a/relayer/processor/types_test.go b/relayer/processor/types_test.go index 39224dc74..36278ed0d 100644 --- a/relayer/processor/types_test.go +++ b/relayer/processor/types_test.go @@ -3,7 +3,8 @@ package processor_test import ( "testing" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" "github.com/cosmos/relayer/v2/relayer/processor" "github.com/stretchr/testify/require" ) @@ -41,3 +42,34 @@ func TestIBCHeaderCachePrune(t *testing.T) { require.Len(t, cache, 5) require.NotNil(t, cache[uint64(15)], cache[uint64(16)], cache[uint64(17)], cache[uint64(18)], cache[uint64(19)]) } + +func TestPacketSequenceStateCachePrune(t *testing.T) { + cache := make(processor.PacketSequenceStateCache) + + for i := uint64(0); i < 50; i++ { + cache[i] = chantypes.EventTypeSendPacket + } + + cache.Prune(100) + + require.Len(t, cache, 50) + + cache.Prune(25) + + require.Len(t, cache, 25) + + min := uint64(1000) + max := uint64(0) + + for seq := range cache { + if seq < min { + min = seq + } + if seq > max { + max = seq + } + } + + require.Equal(t, uint64(25), min) + require.Equal(t, uint64(49), max) +} diff --git a/relayer/provider/matcher.go b/relayer/provider/matcher.go index 72088b0d3..e871c4d86 100644 --- a/relayer/provider/matcher.go +++ b/relayer/provider/matcher.go @@ -8,9 +8,9 @@ import ( sdkcodec "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" - tmclient "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + tmclient "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" ) var tendermintClientCodec = tmClientCodec() diff --git a/relayer/provider/provider.go b/relayer/provider/provider.go index ab34b32d0..c68587a61 100644 --- a/relayer/provider/provider.go +++ b/relayer/provider/provider.go @@ -9,13 +9,13 @@ import ( "github.com/cometbft/cometbft/types" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/gogoproto/proto" - transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - conntypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - commitmenttypes "github.com/cosmos/ibc-go/v7/modules/core/23-commitment/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" - tendermint "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint" + transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + conntypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + commitmenttypes "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + tendermint "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint" "go.uber.org/zap" "go.uber.org/zap/zapcore" ) @@ -232,7 +232,7 @@ type ChainProvider interface { Init(ctx context.Context) error // [Begin] Client IBC message assembly functions - NewClientState(dstChainID string, dstIBCHeader IBCHeader, dstTrustingPeriod, dstUbdPeriod time.Duration, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour bool) (ibcexported.ClientState, error) + NewClientState(dstChainID string, dstIBCHeader IBCHeader, dstTrustingPeriod, dstUbdPeriod, maxClockDrift time.Duration, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour bool) (ibcexported.ClientState, error) MsgCreateClient(clientState ibcexported.ClientState, consensusState ibcexported.ConsensusState) (RelayerMessage, error) @@ -404,7 +404,7 @@ type ChainProvider interface { Key() string Address() (string, error) Timeout() string - TrustingPeriod(ctx context.Context, overrideUnbondingPeriod time.Duration) (time.Duration, error) + TrustingPeriod(ctx context.Context, overrideUnbondingPeriod time.Duration, percentage int64) (time.Duration, error) WaitForNBlocks(ctx context.Context, n int64) error Sprint(toPrint proto.Message) (string, error) diff --git a/relayer/query.go b/relayer/query.go index fa59dba14..0046ed598 100644 --- a/relayer/query.go +++ b/relayer/query.go @@ -8,10 +8,11 @@ import ( "strings" "time" + sdkmath "cosmossdk.io/math" "github.com/avast/retry-go/v4" sdk "github.com/cosmos/cosmos-sdk/types" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" "github.com/cosmos/relayer/v2/relayer/provider" "go.uber.org/zap" "golang.org/x/sync/errgroup" @@ -256,7 +257,7 @@ func QueryBalance(ctx context.Context, chain *Chain, address string, showDenoms var out sdk.Coins for _, c := range coins { - if c.Amount.Equal(sdk.NewInt(0)) { + if c.Amount.Equal(sdkmath.NewInt(0)) { continue } @@ -316,8 +317,9 @@ func SPrintClientExpiration(chain *Chain, expiration time.Time, clientInfo Clien TIME: %s (%s) LAST UPDATE HEIGHT: %d TRUSTING PERIOD: %s + UNBONDING PERIOD: %s `, - chain.ClientID(), chain.ChainID(), status, expirationFormatted, remainingTime.Round(time.Second), clientInfo.LatestHeight.GetRevisionHeight(), clientInfo.TrustingPeriod.String()) + chain.ClientID(), chain.ChainID(), status, expirationFormatted, remainingTime.Round(time.Second), clientInfo.LatestHeight.GetRevisionHeight(), clientInfo.TrustingPeriod.String(), clientInfo.UnbondingTime.Round(time.Second)) return legacyOutput @@ -342,6 +344,7 @@ func SPrintClientExpirationJson(chain *Chain, expiration time.Time, clientInfo C "TIME": fmt.Sprintf("%s (%s)", expirationFormatted, remainingTime.Round(time.Second)), "LAST UPDATE HEIGHT": strconv.FormatUint(clientInfo.LatestHeight.GetRevisionHeight(), 10), "TRUSTING PERIOD": clientInfo.TrustingPeriod.String(), + "UNBONDING PERIOD": clientInfo.UnbondingTime.Round(time.Second).String(), } jsonOutput, err := json.Marshal(data) diff --git a/relayer/query_test.go b/relayer/query_test.go index ea7e4b71d..04a00e075 100644 --- a/relayer/query_test.go +++ b/relayer/query_test.go @@ -6,8 +6,8 @@ import ( "github.com/cosmos/relayer/v2/relayer/chains/cosmos" - clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" - ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" "github.com/stretchr/testify/require" ) diff --git a/relayer/relayMsgs.go b/relayer/relayMsgs.go index 698e8b28a..ac87734f9 100644 --- a/relayer/relayMsgs.go +++ b/relayer/relayMsgs.go @@ -17,10 +17,14 @@ import ( // after a given relay round. MaxTxSize and MaxMsgLength are ignored if they are // set to zero. type RelayMsgs struct { - Src []provider.RelayerMessage `json:"src"` - Dst []provider.RelayerMessage `json:"dst"` - MaxTxSize uint64 `json:"max_tx_size"` // maximum permitted size of the msgs in a bundled relay transaction - MaxMsgLength uint64 `json:"max_msg_length"` // maximum amount of messages in a bundled relay transaction + Src []provider.RelayerMessage `json:"src"` + Dst []provider.RelayerMessage `json:"dst"` + + // maximum permitted size of the msgs in a bundled relay transaction + MaxTxSize uint64 `json:"max_tx_size"` + + // maximum amount of messages in a bundled relay transaction + MaxMsgLength uint64 `json:"max_msg_length"` } // batchSendMessageTimeout is the timeout for sending a single batch of IBC messages to an RPC node. @@ -110,7 +114,7 @@ type SendMsgsResult struct { // SuccessfullySent reports the presence successfully sent batches func (r SendMsgsResult) SuccessfullySent() bool { - return (r.SuccessfulSrcBatches > 0 || r.SuccessfulDstBatches > 0) + return r.SuccessfulSrcBatches > 0 || r.SuccessfulDstBatches > 0 } // PartiallySent reports the presence of both some successfully sent batches @@ -146,7 +150,12 @@ func (r SendMsgsResult) MarshalLogObject(enc zapcore.ObjectEncoder) error { } // Send concurrently sends out r's messages to the corresponding RelayMsgSenders. -func (r *RelayMsgs) Send(ctx context.Context, log *zap.Logger, src, dst RelayMsgSender, memo string) SendMsgsResult { +func (r *RelayMsgs) Send( + ctx context.Context, + log *zap.Logger, + src, dst RelayMsgSender, + memo string, +) SendMsgsResult { var ( wg sync.WaitGroup result SendMsgsResult @@ -156,6 +165,7 @@ func (r *RelayMsgs) Send(ctx context.Context, log *zap.Logger, src, dst RelayMsg wg.Add(1) go r.send(ctx, log, &wg, src, r.Src, memo, &result.SuccessfulSrcBatches, &result.SrcSendError) } + if len(r.Dst) > 0 { wg.Add(1) go r.send(ctx, log, &wg, dst, r.Dst, memo, &result.SuccessfulDstBatches, &result.DstSendError) diff --git a/relayer/strategies.go b/relayer/strategies.go index 9412ecdb9..274e38a2b 100644 --- a/relayer/strategies.go +++ b/relayer/strategies.go @@ -8,10 +8,9 @@ import ( "sync" "time" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/avast/retry-go/v4" - "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/cosmos/relayer/v2/relayer/chains/cosmos" penumbraprocessor "github.com/cosmos/relayer/v2/relayer/chains/penumbra" "github.com/cosmos/relayer/v2/relayer/processor" @@ -40,6 +39,8 @@ func StartRelayer( chains map[string]*Chain, paths []NamedPath, maxMsgLength uint64, + maxReceiverSize, + memoLimit int, memo string, clientUpdateThresholdTime time.Duration, flushInterval time.Duration, @@ -49,7 +50,7 @@ func StartRelayer( metrics *processor.PrometheusMetrics, stuckPacket *processor.StuckPacket, ) chan error { - //prevent incorrect bech32 address prefixed addresses when calling AccAddress.String() + // prevent incorrect bech32 address prefixed addresses when calling AccAddress.String() sdk.SetAddrCacheEnabled(false) errorChan := make(chan error, 1) @@ -70,8 +71,20 @@ func StartRelayer( var filterSrc, filterDst []processor.ChainChannelKey for _, ch := range filter.ChannelList { - ruleSrc := processor.ChainChannelKey{ChainID: p.Src.ChainID, ChannelKey: processor.ChannelKey{ChannelID: ch}} - ruleDst := processor.ChainChannelKey{CounterpartyChainID: p.Src.ChainID, ChannelKey: processor.ChannelKey{CounterpartyChannelID: ch}} + ruleSrc := processor.ChainChannelKey{ + ChainID: p.Src.ChainID, + ChannelKey: processor.ChannelKey{ + ChannelID: ch, + }, + } + + ruleDst := processor.ChainChannelKey{ + CounterpartyChainID: p.Src.ChainID, + ChannelKey: processor.ChannelKey{ + CounterpartyChannelID: ch, + }, + } + filterSrc = append(filterSrc, ruleSrc) filterDst = append(filterDst, ruleDst) } @@ -88,6 +101,8 @@ func StartRelayer( ePaths, initialBlockHistory, maxMsgLength, + maxReceiverSize, + memoLimit, memo, messageLifecycle, clientUpdateThresholdTime, @@ -120,18 +135,18 @@ type path struct { } // chainProcessor returns the corresponding ChainProcessor implementation instance for a pathChain. -func (chain *Chain) chainProcessor( +func (c *Chain) chainProcessor( log *zap.Logger, metrics *processor.PrometheusMetrics, ) processor.ChainProcessor { // Handle new ChainProcessor implementations as cases here - switch p := chain.ChainProvider.(type) { + switch p := c.ChainProvider.(type) { case *penumbraprocessor.PenumbraProvider: return penumbraprocessor.NewPenumbraChainProcessor(log, p) case *cosmos.CosmosProvider: return cosmos.NewCosmosChainProcessor(log, p, metrics) default: - panic(fmt.Errorf("unsupported chain provider type: %T", chain.ChainProvider)) + panic(fmt.Errorf("unsupported chain provider type: %T", c.ChainProvider)) } } @@ -143,6 +158,8 @@ func relayerStartEventProcessor( paths []path, initialBlockHistory uint64, maxMsgLength uint64, + maxReceiverSize, + memoLimit int, memo string, messageLifecycle processor.MessageLifecycle, clientUpdateThresholdTime time.Duration, @@ -168,6 +185,8 @@ func relayerStartEventProcessor( clientUpdateThresholdTime, flushInterval, maxMsgLength, + memoLimit, + maxReceiverSize, )) } @@ -183,7 +202,15 @@ func relayerStartEventProcessor( } // relayerStartLegacy is the main loop of the relayer. -func relayerStartLegacy(ctx context.Context, log *zap.Logger, src, dst *Chain, filter ChannelFilter, maxTxSize, maxMsgLength uint64, memo string, errCh chan<- error) { +func relayerStartLegacy( + ctx context.Context, + log *zap.Logger, + src, dst *Chain, + filter ChannelFilter, + maxTxSize, maxMsgLength uint64, + memo string, + errCh chan<- error, +) { defer close(errCh) // Query the list of channels on the src connection. diff --git a/relayer/strategies_test.go b/relayer/strategies_test.go index 680207760..25c0ccf91 100644 --- a/relayer/strategies_test.go +++ b/relayer/strategies_test.go @@ -3,7 +3,7 @@ package relayer import ( "testing" - chantypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" "github.com/stretchr/testify/require" ) diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index ae4f20240..ef64d57b1 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -21,8 +21,6 @@ buf generate --template proto/buf.gen.penumbra.yaml buf.build/penumbra-zone/penu # # Note: Proto files are suffixed with the current binary version. -rm -r github.com/cosmos/relayer/v2/relayer/chains/penumbra/client -rm -r github.com/cosmos/relayer/v2/relayer/chains/penumbra/narsil cp -r github.com/cosmos/relayer/v2/* ./ cp -r github.com/cosmos/relayer/relayer/* relayer/ rm -rf github.com